Add option for using generators for instance check

param/_utils.py

@@ -612,3 +612,15 @@ def async_executor(func):
         task.add_done_callback(_running_tasks.discard)
     else:
         event_loop.run_until_complete(func())
+
+
+def anyinstance(obj, class_tuple_generator):
+    if inspect.isgeneratorfunction(class_tuple_generator):
+        class_tuple_generator = tuple(class_tuple_generator())
+    return isinstance(obj, class_tuple_generator)
+
+
+def anysubclass(obj, class_tuple_generator):
+    if inspect.isgeneratorfunction(class_tuple_generator):
+        class_tuple_generator = tuple(class_tuple_generator())
+    return issubclass(obj, class_tuple_generator)

param/parameterized.py

@@ -16,8 +16,8 @@
 import logging
 import numbers
 import operator
-import random
 import re
+import sys
 import types
 import typing
 import warnings
@@ -74,15 +74,18 @@
 
 from inspect import getfullargspec
 
-dt_types = (dt.datetime, dt.date)
-_int_types = (int,)
+def _dt_types():
+    yield dt.datetime
+    yield dt.date
+    if "numpy" in sys.modules:
+        import numpy as np
+        yield np.datetime64
 
-try:
-    import numpy as np
-    dt_types = dt_types + (np.datetime64,)
-    _int_types = _int_types + (np.integer,)
-except:
-    pass
+def _int_types():
+    yield int
+    if "numpy" in sys.modules:
+        import numpy as np
+        yield np.integer
 
 VERBOSE = INFO - 1
 logging.addLevelName(VERBOSE, "VERBOSE")
@@ -1714,11 +1717,18 @@ class Comparator:
         type(None): operator.eq,
         lambda o: hasattr(o, '_infinitely_iterable'): operator.eq,  # Time
     }
-    equalities.update({dtt: operator.eq for dtt in dt_types})
+    gen_equalities = {
+        _dt_types: operator.eq
+    }
 
     @classmethod
     def is_equal(cls, obj1, obj2):
-        for eq_type, eq in cls.equalities.items():
+        equals = cls.equalities.copy()
+        for gen, op in cls.gen_equalities.items():
+            for t in gen():
+                equals[t] = op
+
+        for eq_type, eq in equals.items():
             try:
                 are_instances = isinstance(obj1, eq_type) and isinstance(obj2, eq_type)
             except TypeError:
@@ -3804,6 +3814,9 @@ def pprint(val,imports=None, prefix="\n    ", settings=[],
     elif type(val) in script_repr_reg:
         rep = script_repr_reg[type(val)](val,imports,prefix,settings)
 
+    elif type(val) in (_np_random(), _py_random()):
+        rep = None
+
     elif isinstance(val, Parameterized) or (type(val) is type and issubclass(val, Parameterized)):
         rep=val.param.pprint(imports=imports, prefix=prefix+"    ",
                         qualify=qualify, unknown_value=unknown_value,
@@ -3838,17 +3851,16 @@ def container_script_repr(container,imports,prefix,settings):
     return rep
 
 
-def empty_script_repr(*args): # pyflakes:ignore (unused arguments):
-    return None
+def _np_random():
+    if "numpy" in sys.modules:
+        import numpy as np
+        return np.random.RandomState
 
-try:
-    # Suppress scriptrepr for objects not yet having a useful string representation
-    import numpy
-    script_repr_reg[random.Random] = empty_script_repr
-    script_repr_reg[numpy.random.RandomState] = empty_script_repr
 
-except ImportError:
-    pass # Support added only if those libraries are available
+def _py_random():
+    if "random" in sys.modules:
+        import random
+        return random.Random
 
 
 def function_script_repr(fn,imports,prefix,settings):

param/parameters.py

@@ -34,7 +34,7 @@
 
 from .parameterized import (
     Parameterized, Parameter, ParameterizedFunction, ParamOverrides, String,
-    Undefined, get_logger, instance_descriptor, dt_types,
+    Undefined, get_logger, instance_descriptor, _dt_types,
     _int_types, _identity_hook
 )
 from ._utils import (
@@ -51,6 +51,8 @@
     concrete_descendents,
     _abbreviate_paths,
     _to_datetime,
+    anyinstance,
+    anysubclass,
 )
 
 #-----------------------------------------------------------------------------
@@ -94,7 +96,7 @@ def guess_param_types(**kwargs):
         kws = dict(default=v, constant=True)
         if isinstance(v, Parameter):
             params[k] = v
-        elif isinstance(v, dt_types):
+        elif anyinstance(v, _dt_types):
             params[k] = Date(**kws)
         elif isinstance(v, bool):
             params[k] = Boolean(**kws)
@@ -109,7 +111,7 @@ def guess_param_types(**kwargs):
         elif isinstance(v, tuple):
             if all(_is_number(el) for el in v):
                 params[k] = NumericTuple(**kws)
-            elif all(isinstance(el, dt_types) for el in v) and len(v)==2:
+            elif all(anyinstance(el, _dt_types) for el in v) and len(v)==2:
                 params[k] = DateRange(**kws)
             else:
                 params[k] = Tuple(**kws)
@@ -141,7 +143,7 @@ def parameterized_class(name, params, bases=Parameterized):
     Dynamically create a parameterized class with the given name and the
     supplied parameters, inheriting from the specified base(s).
     """
-    if not (isinstance(bases, list) or isinstance(bases, tuple)):
+    if not isinstance(bases, (list, tuple)):
         bases=[bases]
     return type(name, tuple(bases), params)
 
@@ -852,7 +854,7 @@ def _validate_value(self, val, allow_None):
         if allow_None and val is None:
             return
 
-        if not isinstance(val, _int_types):
+        if not anyinstance(val, _int_types):
             raise ValueError(
                 f"{_validate_error_prefix(self)} must be an integer, "
                 f"not {type(val)}."
@@ -917,14 +919,14 @@ def _validate_value(self, val, allow_None):
         if self.allow_None and val is None:
             return
 
-        if not isinstance(val, dt_types) and not (allow_None and val is None):
+        if not anyinstance(val, _dt_types) and not (allow_None and val is None):
             raise ValueError(
                 f"{_validate_error_prefix(self)} only takes datetime and "
                 f"date types, not {type(val)}."
             )
 
     def _validate_step(self, val, step):
-        if step is not None and not isinstance(step, dt_types):
+        if step is not None and not anyinstance(step, _dt_types):
             raise ValueError(
                 f"{_validate_error_prefix(self, 'step')} can only be None, "
                 f"a datetime or date type, not {type(step)}."
@@ -1355,7 +1357,7 @@ class DateRange(Range):
     """
 
     def _validate_bound_type(self, value, position, kind):
-        if not isinstance(value, dt_types):
+        if not anyinstance(value, _dt_types):
             raise ValueError(
                 f"{_validate_error_prefix(self)} {position} {kind} can only be "
                 f"None or a date/datetime value, not {type(value)}."
@@ -1379,7 +1381,7 @@ def _validate_value(self, val, allow_None):
                 f"not {type(val)}."
             )
         for n in val:
-            if isinstance(n, dt_types):
+            if anyinstance(n, _dt_types):
                 continue
             raise ValueError(
                 f"{_validate_error_prefix(self)} only takes date/datetime "
@@ -2184,18 +2186,20 @@ def _validate(self, val):
     def _validate_class_(self, val, class_, is_instance):
         if (val is None and self.allow_None):
             return
+        if (is_instance and anyinstance(val, class_)) or (not is_instance and anysubclass(val, class_)):
+            return
+
         if isinstance(class_, tuple):
-            class_name = ('(%s)' % ', '.join(cl.__name__ for cl in class_))
+            class_name = ('({})'.format(', '.join(cl.__name__ for cl in class_)))
+        elif inspect.isgenerator(class_):
+            class_name = ('({})'.format(', '.join(cl.__name__ for cl in class_())))
         else:
             class_name = class_.__name__
-        if is_instance:
-            if not (isinstance(val, class_)):
-                raise ValueError(
-                    f"{_validate_error_prefix(self)} value must be an instance of {class_name}, not {val!r}.")
-        else:
-            if not (issubclass(val, class_)):
-                raise ValueError(
-                    f"{_validate_error_prefix(self)} value must be a subclass of {class_name}, not {val}.")
+
+        raise ValueError(
+            f"{_validate_error_prefix(self)} value must be "
+            f"{'an instance' if is_instance else 'a subclass'} of {class_name}, not {val!r}."
+        )
 
     def get_range(self):
         """
@@ -2559,7 +2563,7 @@ def _validate_item_type(self, val, item_type):
         if item_type is None or (self.allow_None and val is None):
             return
         for v in val:
-            if isinstance(v, item_type):
+            if anyinstance(v, item_type):
                 continue
             raise TypeError(
                 f"{_validate_error_prefix(self)} items must be instances "

tests/testimports.py

@@ -0,0 +1,20 @@
+import sys
+from subprocess import check_output
+from textwrap import dedent
+
+
+def test_no_blocklist_imports():
+    check = """\
+    import sys
+    import param
+
+    blocklist = {"numpy", "IPython", "pandas"}
+    mods = blocklist & set(sys.modules)
+
+    if mods:
+        print(", ".join(mods), end="")
+    """
+
+    output = check_output([sys.executable, '-c', dedent(check)])
+
+    assert output == b""