adding PydanticOmit exception (#282)

* adding PydanticOmit exception

* more errors

Author: samuelcolvin

pydantic_core/__init__.py

@@ -1,6 +1,7 @@
 from ._pydantic_core import (
     PydanticCustomError,
     PydanticErrorKind,
+    PydanticOmit,
     SchemaError,
     SchemaValidator,
     ValidationError,
@@ -17,4 +18,5 @@
     'ValidationError',
     'PydanticCustomError',
     'PydanticErrorKind',
+    'PydanticOmit',
 )

pydantic_core/_pydantic_core.pyi

@@ -8,7 +8,15 @@ if sys.version_info < (3, 11):
 else:
     from typing import NotRequired
 
-__all__ = '__version__', 'SchemaValidator', 'SchemaError', 'ValidationError', 'PydanticCustomError', 'PydanticErrorKind'
+__all__ = (
+    '__version__',
+    'SchemaValidator',
+    'SchemaError',
+    'ValidationError',
+    'PydanticCustomError',
+    'PydanticErrorKind',
+    'PydanticOmit',
+)
 __version__: str
 build_profile: str
 
@@ -58,3 +66,6 @@ class PydanticErrorKind(ValueError):
 
     def __init__(self, kind: str, context: 'dict[str, str | int] | None' = None) -> None: ...
     def message(self) -> str: ...
+
+class PydanticOmit(Exception):
+    def __init__(self) -> None: ...

src/errors/mod.rs

@@ -10,7 +10,7 @@ pub use self::kinds::ErrorKind;
 pub use self::line_error::{pretty_line_errors, InputValue, ValError, ValLineError, ValResult};
 pub use self::location::LocItem;
 pub use self::validation_exception::ValidationError;
-pub use self::value_exception::{PydanticCustomError, PydanticErrorKind};
+pub use self::value_exception::{PydanticCustomError, PydanticErrorKind, PydanticOmit};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
     let value = err.value(py);

src/errors/value_exception.rs

@@ -1,11 +1,31 @@
-use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::exceptions::{PyException, PyTypeError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
 use crate::input::Input;
 
 use super::{ErrorKind, ValError};
 
+#[pyclass(extends=PyException, module="pydantic_core._pydantic_core")]
+#[derive(Debug, Clone)]
+pub struct PydanticOmit {}
+
+#[pymethods]
+impl PydanticOmit {
+    #[new]
+    pub fn py_new() -> Self {
+        Self {}
+    }
+
+    fn __str__(&self) -> &'static str {
+        self.__repr__()
+    }
+
+    fn __repr__(&self) -> &'static str {
+        "PydanticOmit()"
+    }
+}
+
 #[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
 #[derive(Debug, Clone, Default)]
 pub struct PydanticCustomError {

src/lib.rs

@@ -18,7 +18,7 @@ mod validators;
 
 // required for benchmarks
 pub use build_tools::SchemaError;
-pub use errors::{PydanticCustomError, PydanticErrorKind, ValidationError};
+pub use errors::{PydanticCustomError, PydanticErrorKind, PydanticOmit, ValidationError};
 pub use validators::SchemaValidator;
 
 pub fn get_version() -> String {
@@ -40,5 +40,6 @@ fn _pydantic_core(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<SchemaError>()?;
     m.add_class::<PydanticCustomError>()?;
     m.add_class::<PydanticErrorKind>()?;
+    m.add_class::<PydanticOmit>()?;
     Ok(())
 }

src/validators/function.rs

@@ -4,7 +4,9 @@ use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict};
 
 use crate::build_tools::{py_error, SchemaDict};
-use crate::errors::{ErrorKind, LocItem, PydanticCustomError, PydanticErrorKind, ValError, ValResult, ValidationError};
+use crate::errors::{
+    ErrorKind, LocItem, PydanticCustomError, PydanticErrorKind, PydanticOmit, ValError, ValResult, ValidationError,
+};
 use crate::input::Input;
 use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
@@ -292,6 +294,8 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
         }
     } else if err.is_instance_of::<PyAssertionError>(py) {
         py_err_string!(err.value(py), AssertionError, input)
+    } else if err.is_instance_of::<PydanticOmit>(py) {
+        ValError::Omit
     } else {
         ValError::InternalErr(err)
     }

tests/validators/test_function.py

@@ -5,9 +5,16 @@
 
 import pytest
 
-from pydantic_core import PydanticCustomError, PydanticErrorKind, SchemaError, SchemaValidator, ValidationError
+from pydantic_core import (
+    PydanticCustomError,
+    PydanticErrorKind,
+    PydanticOmit,
+    SchemaError,
+    SchemaValidator,
+    ValidationError,
+)
 
-from ..conftest import plain_repr
+from ..conftest import PyAndJson, plain_repr
 
 
 def test_function_before():
@@ -635,3 +642,33 @@ def test_error_kind(kind, message, context):
     assert e.message() == message
     assert e.kind == kind
     assert e.context == context
+
+
+def test_pydantic_value_error_plain(py_and_json: PyAndJson):
+    def f(input_value, **kwargs):
+        raise PydanticCustomError
+
+    v = py_and_json({'type': 'function', 'mode': 'plain', 'function': f})
+    with pytest.raises(TypeError, match='missing 2 required positional arguments'):
+        v.validate_test('4')
+
+
+@pytest.mark.parametrize('exception', [PydanticOmit(), PydanticOmit])
+def test_list_omit_exception(py_and_json: PyAndJson, exception):
+    def f(input_value, **kwargs):
+        if input_value % 2 == 0:
+            raise exception
+        return input_value
+
+    v = py_and_json(
+        {
+            'type': 'list',
+            'items_schema': {'type': 'function', 'schema': {'type': 'int'}, 'mode': 'after', 'function': f},
+        }
+    )
+    assert v.validate_test([1, 2, '3', '4']) == [1, 3]
+
+
+def test_omit_exc_repr():
+    assert repr(PydanticOmit()) == 'PydanticOmit()'
+    assert str(PydanticOmit()) == 'PydanticOmit()'