Added StrictBytes type (pydantic#2136)

* Added StrictBytes type

* updated tests for StrictBytes, updated relevant sections in documentation for StrictBytes and ConstrainedBytes

* added changelog

* chore: typo in change

Co-authored-by: Eric Jolibois <em.jolibois@gmail.com>

changes/2136-rlizzo.md

@@ -0,0 +1 @@
+Added `StrictBytes` type as well as `strict=False` option to `ConstrainedBytes`.

docs/examples/types_strict.py

@@ -1,4 +1,21 @@
-from pydantic import BaseModel, StrictBool, StrictInt, ValidationError, confloat
+from pydantic import (
+    BaseModel,
+    StrictBytes,
+    StrictBool,
+    StrictInt,
+    ValidationError,
+    confloat,
+)
+
+
+class StrictBytesModel(BaseModel):
+    strict_bytes: StrictBytes
+
+
+try:
+    StrictBytesModel(strict_bytes='hello world')
+except ValidationError as e:
+    print(e)
 
 
 class StrictIntModel(BaseModel):

docs/usage/types.md

@@ -721,14 +721,16 @@ Where `Field` refers to the [field function](schema.md#field-customisation).
 
 ## Strict Types
 
-You can use the `StrictStr`, `StrictInt`, `StrictFloat`, and `StrictBool` types
+You can use the `StrictStr`, `StrictBytes`, `StrictInt`, `StrictFloat`, and `StrictBool` types 
 to prevent coercion from compatible types.
 These types will only pass validation when the validated value is of the respective type or is a subtype of that type.
-This behavior is also exposed via the `strict` field of the `ConstrainedStr`, `ConstrainedFloat` and
-`ConstrainedInt` classes and can be combined with a multitude of complex validation rules.
+This behavior is also exposed via the `strict` field of the `ConstrainedStr`, `ConstrainedBytes`, 
+`ConstrainedFloat` and `ConstrainedInt` classes and can be combined with a multitude of complex validation rules.
 
 The following caveats apply:
 
+- `StrictBytes` (and the `strict` option of `ConstrainedBytes`) will accept both `bytes`,
+   and `bytearray` types. 
 - `StrictInt` (and the `strict` option of `ConstrainedInt`) will not accept `bool` types,
     even though `bool` is a subclass of `int` in Python. Other subclasses will work.
 - `StrictFloat` (and the `strict` option of `ConstrainedFloat`) will not accept `int`.

pydantic/__init__.py

@@ -97,6 +97,7 @@
     'SecretStr',
     'SecretBytes',
     'StrictBool',
+    'StrictBytes',
     'StrictInt',
     'StrictFloat',
     'PaymentCardNumber',

pydantic/types.py

@@ -39,6 +39,7 @@
     path_validator,
     set_validator,
     str_validator,
+    strict_bytes_validator,
     strict_float_validator,
     strict_int_validator,
     strict_str_validator,
@@ -84,6 +85,7 @@
     'SecretStr',
     'SecretBytes',
     'StrictBool',
+    'StrictBytes',
     'StrictInt',
     'StrictFloat',
     'PaymentCardNumber',
@@ -112,18 +114,23 @@ class ConstrainedBytes(bytes):
     strip_whitespace = False
     min_length: OptionalInt = None
     max_length: OptionalInt = None
+    strict: bool = False
 
     @classmethod
     def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
         update_not_none(field_schema, minLength=cls.min_length, maxLength=cls.max_length)
 
     @classmethod
     def __get_validators__(cls) -> 'CallableGenerator':
-        yield bytes_validator
+        yield strict_bytes_validator if cls.strict else bytes_validator
         yield constr_strip_whitespace
         yield constr_length_validator
 
 
+class StrictBytes(ConstrainedBytes):
+    strict = True
+
+
 def conbytes(*, strip_whitespace: bool = False, min_length: int = None, max_length: int = None) -> Type[bytes]:
     # use kwargs then define conf in a dict to aid with IDE type hinting
     namespace = dict(strip_whitespace=strip_whitespace, min_length=min_length, max_length=max_length)

pydantic/validators.py

@@ -82,6 +82,15 @@ def bytes_validator(v: Any) -> bytes:
         raise errors.BytesError()
 
 
+def strict_bytes_validator(v: Any) -> Union[bytes]:
+    if isinstance(v, bytes):
+        return v
+    elif isinstance(v, bytearray):
+        return bytes(v)
+    else:
+        raise errors.BytesError()
+
+
 BOOL_FALSE = {0, '0', 'off', 'f', 'false', 'n', 'no'}
 BOOL_TRUE = {1, '1', 'on', 't', 'true', 'y', 'yes'}
 

tests/test_types.py

@@ -53,6 +53,7 @@
     SecretBytes,
     SecretStr,
     StrictBool,
+    StrictBytes,
     StrictFloat,
     StrictInt,
     StrictStr,
@@ -1300,6 +1301,39 @@ class Model(BaseModel):
     ]
 
 
+def test_strict_bytes():
+    class Model(BaseModel):
+        v: StrictBytes
+
+    assert Model(v=b'foobar').v == b'foobar'
+    assert Model(v=bytearray('foobar', 'utf-8')).v == b'foobar'
+
+    with pytest.raises(ValidationError):
+        Model(v='foostring')
+
+    with pytest.raises(ValidationError):
+        Model(v=42)
+
+    with pytest.raises(ValidationError):
+        Model(v=0.42)
+
+
+def test_strict_bytes_subclass():
+    class MyStrictBytes(StrictBytes):
+        pass
+
+    class Model(BaseModel):
+        v: MyStrictBytes
+
+    a = Model(v=MyStrictBytes(b'foobar'))
+    assert isinstance(a.v, MyStrictBytes)
+    assert a.v == b'foobar'
+
+    b = Model(v=MyStrictBytes(bytearray('foobar', 'utf-8')))
+    assert isinstance(b.v, MyStrictBytes)
+    assert b.v == 'foobar'.encode()
+
+
 def test_strict_str():
     class Model(BaseModel):
         v: StrictStr