holoviz · philippjfr · Jan 7, 2023 · Oct 7, 2021 · Jan 6, 2023 · Jan 6, 2023
diff --git a/param/__init__.py b/param/__init__.py
@@ -735,6 +735,42 @@ def get_soft_bounds(bounds, softbounds):
     return (l, u)
 
 
+class Bytes(Parameter):
+    """
+    A Bytes Parameter, with a default value and optional regular
+    expression (regex) matching.
+
+    Similar to the String parameter, but instead of type basestring
+    this parameter only allows objects of type bytes (e.g. b'bytes').
+    """
+
+    __slots__ = ['regex']
+
+    def __init__(self, default=b"", regex=None, allow_None=False, **kwargs):
+        super(Bytes, self).__init__(default=default, allow_None=allow_None, **kwargs)
+        self.regex = regex
+        self.allow_None = (default is None or allow_None)
+        self._validate(default)
+
+    def _validate_regex(self, val, regex):
+        if (val is None and self.allow_None):
+            return
+        if regex is not None and re.match(regex, val) is None:
+            raise ValueError("Bytes parameter %r value %r does not match regex %r."
+                             % (self.name, val, regex))
+
+    def _validate_value(self, val, allow_None):
+        if allow_None and val is None:
+            return
+        if not isinstance(val, bytes):
+            raise ValueError("Bytes parameter %r only takes a byte string value, "
+                             "not value of type %s." % (self.name, type(val)))
+
+    def _validate(self, val):
+        self._validate_value(val, self.allow_None)
+        self._validate_regex(val, self.regex)
+
+
 class Number(Dynamic):
     """
     A numeric Dynamic Parameter, with a default value and optional bounds.

diff --git a/tests/API1/testbytesparam.py b/tests/API1/testbytesparam.py
@@ -0,0 +1,80 @@
+"""
+Unit test for Bytes parameters
+"""
+import sys
+
+import pytest
+
+from . import API1TestCase
+
+import param
+
+
+ip_regex = br'^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
+
+class TestBytesParameters(API1TestCase):
+
+    def test_bytes_default_type(self):
+        if sys.version_info.major < 3:
+            pytest.skip()
+
+        with pytest.raises(ValueError):
+            class A(param.Parameterized):
+                s = param.Bytes('abc')
+
+    def test_bytes_value_type(self):
+        if sys.version_info.major < 3:
+            pytest.skip()
+
+        class A(param.Parameterized):
+            s = param.Bytes()
+
+        with pytest.raises(ValueError):
+            A(s='abc')
+
+
+    def test_regex_ok(self):
+        class A(param.Parameterized):
+            s = param.Bytes(b'0.0.0.0', ip_regex)
+
+        a = A()
+        a.s = b'123.123.0.1'
+
+    def test_reject_none(self):
+        class A(param.Parameterized):
+            s = param.Bytes(b'0.0.0.0', ip_regex)
+
+        a = A()
+
+        cls = 'class' if sys.version_info.major > 2 else 'type'
+        exception = "Bytes parameter 's' only takes a byte string value, not value of type <%s 'NoneType'>." % cls
+        with self.assertRaisesRegex(ValueError, exception):
+            a.s = None  # because allow_None should be False
+
+    def test_default_none(self):
+        class A(param.Parameterized):
+            s = param.Bytes(None, ip_regex)
+
+        a = A()
+        a.s = b'123.123.0.1'
+        a.s = None  # because allow_None should be True with default of None
+
+    def test_regex_incorrect(self):
+        class A(param.Parameterized):
+            s = param.Bytes(b'0.0.0.0', regex=ip_regex)
+
+        a = A()
+
+        b = 'b' if sys.version_info.major > 2 else ''
+        exception = "Bytes parameter 's' value %s'123.123.0.256' does not match regex %r."  % (b, ip_regex)
+        with self.assertRaises(ValueError) as e:
+            a.s = b'123.123.0.256'
+        self.assertEqual(str(e.exception), exception)
+
+    def test_regex_incorrect_default(self):
+        b = 'b' if sys.version_info.major > 2 else ''
+        exception = "Bytes parameter None value %s'' does not match regex %r." % (b, ip_regex)
+        with self.assertRaises(ValueError) as e:
+            class A(param.Parameterized):
+                s = param.Bytes(regex=ip_regex)  # default value '' does not match regular expression
+        self.assertEqual(str(e.exception), exception)