diff --git a/doc/OnlineDocs/conf.py b/doc/OnlineDocs/conf.py
index 04fe458407b..1aab4cd76c2 100644
--- a/doc/OnlineDocs/conf.py
+++ b/doc/OnlineDocs/conf.py
@@ -271,7 +271,7 @@ def check_output(self, want, got, optionflags):
     yaml_available, networkx_available, matplotlib_available,
     pympler_available, dill_available,
 )
-pint_available = attempt_import('pint', defer_check=False)[1]
+pint_available = attempt_import('pint', defer_import=False)[1]
 from pyomo.contrib.parmest.parmest import parmest_available
 
 import pyomo.environ as _pe # (trigger all plugin registrations)
diff --git a/doc/OnlineDocs/contributed_packages/pyros.rst b/doc/OnlineDocs/contributed_packages/pyros.rst
index aad37a9685a..76a751dd994 100644
--- a/doc/OnlineDocs/contributed_packages/pyros.rst
+++ b/doc/OnlineDocs/contributed_packages/pyros.rst
@@ -689,7 +689,7 @@ could have been equivalently written as:
   ...     },
   ... )
   ==============================================================================
-  PyROS: The Pyomo Robust Optimization Solver.
+  PyROS: The Pyomo Robust Optimization Solver...
   ...
   ------------------------------------------------------------------------------
   Robust optimal solution identified.
diff --git a/pyomo/common/dependencies.py b/pyomo/common/dependencies.py
index 9e96fdd5860..472b0011edb 100644
--- a/pyomo/common/dependencies.py
+++ b/pyomo/common/dependencies.py
@@ -9,13 +9,16 @@
 #  This software is distributed under the 3-clause BSD License.
 #  ___________________________________________________________________________
 
-from collections.abc import Mapping
 import inspect
 import importlib
 import logging
 import sys
 import warnings
 
+from collections.abc import Mapping
+from types import ModuleType
+from typing import List
+
 from .deprecation import deprecated, deprecation_warning, in_testing_environment
 from .errors import DeferredImportError
 
@@ -127,7 +130,7 @@ class DeferredImportModule(object):
 
     This object is returned by :py:func:`attempt_import()` in lieu of
     the module when :py:func:`attempt_import()` is called with
-    ``defer_check=True``.  Any attempts to access attributes on this
+    ``defer_import=True``.  Any attempts to access attributes on this
     object will trigger the actual module import and return either the
     appropriate module attribute or else if the module import fails,
     raise a :py:class:`.DeferredImportError` exception.
@@ -312,6 +315,12 @@ def __init__(
         self._module = None
         self._available = None
         self._deferred_submodules = deferred_submodules
+        # If this import has a callback, then record this deferred
+        # import so that any direct imports of this module also trigger
+        # the resolution of this DeferredImportIndicator (and the
+        # corresponding callback)
+        if callback is not None:
+            DeferredImportCallbackFinder._callbacks.setdefault(name, []).append(self)
 
     def __bool__(self):
         self.resolve()
@@ -433,6 +442,83 @@ def check_min_version(module, min_version):
 check_min_version._parser = None
 
 
+#
+# Note that we are duck-typing the Loader and MetaPathFinder base
+# classes from importlib.abc.  This avoids a (surprisingly costly)
+# import of importlib.abc
+#
+class DeferredImportCallbackLoader:
+    """Custom Loader to resolve registered :py:class:`DeferredImportIndicator` objects
+
+    This :py:class:`importlib.abc.Loader` loader wraps a regular loader
+    and automatically resolves the registered
+    :py:class:`DeferredImportIndicator` objects after the module is
+    loaded.
+
+    """
+
+    def __init__(self, loader, deferred_indicators: List[DeferredImportIndicator]):
+        self._loader = loader
+        self._deferred_indicators = deferred_indicators
+
+    def module_repr(self, module: ModuleType) -> str:
+        return self._loader.module_repr(module)
+
+    def create_module(self, spec) -> ModuleType:
+        return self._loader.create_module(spec)
+
+    def exec_module(self, module: ModuleType) -> None:
+        self._loader.exec_module(module)
+        # Now that the module has been loaded, trigger the resolution of
+        # the deferred indicators (and their associated callbacks)
+        for deferred in self._deferred_indicators:
+            deferred.resolve()
+
+    def load_module(self, fullname) -> ModuleType:
+        return self._loader.load_module(fullname)
+
+
+class DeferredImportCallbackFinder:
+    """Custom Finder that will wrap the normal loader to trigger callbacks
+
+    This :py:class:`importlib.abc.MetaPathFinder` finder will wrap the
+    normal loader returned by ``PathFinder`` with a loader that will
+    trigger custom callbacks after the module is loaded.  We use this to
+    trigger the post import callbacks registered through
+    :py:func:`attempt_import` even when a user imports the target library
+    directly (and not through attribute access on the
+    :py:class:`DeferredImportModule`.
+
+    """
+
+    _callbacks = {}
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname not in self._callbacks:
+            return None
+
+        spec = importlib.machinery.PathFinder.find_spec(fullname, path, target)
+        if spec is None:
+            # Module not found.  Returning None will proceed to the next
+            # finder (which is likely to raise a ModuleNotFoundError)
+            return None
+        spec.loader = DeferredImportCallbackLoader(
+            spec.loader, self._callbacks[fullname]
+        )
+        return spec
+
+    def invalidate_caches(self):
+        pass
+
+
+_DeferredImportCallbackFinder = DeferredImportCallbackFinder()
+# Insert the DeferredImportCallbackFinder at the beginning of the
+# sys.meta_path so that it is found before the standard finders (so that
+# we can correctly inject the resolution of the DeferredImportIndicators
+# -- which triggers the needed callbacks)
+sys.meta_path.insert(0, _DeferredImportCallbackFinder)
+
+
 def attempt_import(
     name,
     error_message=None,
@@ -441,7 +527,8 @@ def attempt_import(
     alt_names=None,
     callback=None,
     importer=None,
-    defer_check=True,
+    defer_check=None,
+    defer_import=None,
     deferred_submodules=None,
     catch_exceptions=None,
 ):
@@ -495,7 +582,8 @@ def attempt_import(
         The message for the exception raised by :py:class:`ModuleUnavailable`
 
     only_catch_importerror: bool, optional
-        DEPRECATED: use catch_exceptions instead or only_catch_importerror.
+        DEPRECATED: use ``catch_exceptions`` instead of ``only_catch_importerror``.
+
         If True (the default), exceptions other than ``ImportError`` raised
         during module import will be reraised.  If False, any exception
         will result in returning a :py:class:`ModuleUnavailable` object.
@@ -506,13 +594,14 @@ def attempt_import(
         ``module.__version__``)
 
     alt_names: list, optional
-        DEPRECATED: alt_names no longer needs to be specified and is ignored.
+        DEPRECATED: ``alt_names`` no longer needs to be specified and is ignored.
+
         A list of common alternate names by which to look for this
         module in the ``globals()`` namespaces.  For example, the alt_names
         for NumPy would be ``['np']``.  (deprecated in version 6.0)
 
-    callback: function, optional
-        A function with the signature "``fcn(module, available)``" that
+    callback: Callable[[ModuleType, bool], None], optional
+        A function with the signature ``fcn(module, available)`` that
         will be called after the import is first attempted.
 
     importer: function, optional
@@ -522,10 +611,16 @@ def attempt_import(
         want to import/return the first one that is available.
 
     defer_check: bool, optional
-        If True (the default), then the attempted import is deferred
-        until the first use of either the module or the availability
-        flag.  The method will return instances of :py:class:`DeferredImportModule`
-        and :py:class:`DeferredImportIndicator`.
+        DEPRECATED: renamed to ``defer_import`` (deprecated in version 6.7.2.dev0)
+
+    defer_import: bool, optional
+        If True, then the attempted import is deferred until the first
+        use of either the module or the availability flag.  The method
+        will return instances of :py:class:`DeferredImportModule` and
+        :py:class:`DeferredImportIndicator`.  If False, the import will
+        be attempted immediately.  If not set, then the import will be
+        deferred unless the ``name`` is already present in
+        ``sys.modules``.
 
     deferred_submodules: Iterable[str], optional
         If provided, an iterable of submodule names within this module
@@ -576,9 +671,26 @@ def attempt_import(
     if catch_exceptions is None:
         catch_exceptions = (ImportError,)
 
+    if defer_check is not None:
+        deprecation_warning(
+            'defer_check=%s is deprecated.  Please use defer_import' % (defer_check,),
+            version='6.7.2.dev0',
+        )
+        assert defer_import is None
+        defer_import = defer_check
+
+    # If the module has already been imported, there is no reason to
+    # further defer things: just import it.
+    if defer_import is None:
+        if name in sys.modules:
+            defer_import = False
+            deferred_submodules = None
+        else:
+            defer_import = True
+
     # If we are going to defer the check until later, return the
     # deferred import module object
-    if defer_check:
+    if defer_import:
         if deferred_submodules:
             if isinstance(deferred_submodules, Mapping):
                 deprecation_warning(
@@ -621,7 +733,7 @@ def attempt_import(
         return DeferredImportModule(indicator, deferred, None), indicator
 
     if deferred_submodules:
-        raise ValueError("deferred_submodules is only valid if defer_check==True")
+        raise ValueError("deferred_submodules is only valid if defer_import==True")
 
     return _perform_import(
         name=name,
@@ -672,6 +784,11 @@ def _perform_import(
     return module, False
 
 
+@deprecated(
+    "``declare_deferred_modules_as_importable()`` is deprecated.  "
+    "Use the :py:class:`declare_modules_as_importable` context manager.",
+    version='6.7.2.dev0',
+)
 def declare_deferred_modules_as_importable(globals_dict):
     """Make all :py:class:`DeferredImportModules` in ``globals_dict`` importable
 
@@ -698,6 +815,7 @@ def declare_deferred_modules_as_importable(globals_dict):
        ...     'scipy', callback=_finalize_scipy,
        ...     deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'])
        >>> declare_deferred_modules_as_importable(globals())
+       WARNING: DEPRECATED: ...
 
     Which enables users to use:
 
@@ -712,20 +830,87 @@ def declare_deferred_modules_as_importable(globals_dict):
     :py:class:`ModuleUnavailable` instance.
 
     """
-    _global_name = globals_dict['__name__'] + '.'
-    deferred = list(
-        (k, v) for k, v in globals_dict.items() if type(v) is DeferredImportModule
-    )
-    while deferred:
-        name, mod = deferred.pop(0)
-        mod.__path__ = None
-        mod.__spec__ = None
-        sys.modules[_global_name + name] = mod
-        deferred.extend(
-            (name + '.' + k, v)
-            for k, v in mod.__dict__.items()
-            if type(v) is DeferredImportModule
-        )
+    return declare_modules_as_importable(globals_dict).__exit__(None, None, None)
+
+
+class declare_modules_as_importable(object):
+    """Make all :py:class:`ModuleType` and :py:class:`DeferredImportModules`
+    importable through the ``globals_dict`` context.
+
+    This context manager will detect all modules imported into the
+    specified ``globals_dict`` environment (either directly or through
+    :py:func:`attempt_import`) and will make those modules importable
+    from the specified ``globals_dict`` context.  It works by detecting
+    changes in the specified ``globals_dict`` dictionary and adding any new
+    modules or instances of :py:class:`DeferredImportModule` that it
+    finds (and any of their deferred submodules) to ``sys.modules`` so
+    that the modules can be imported through the ``globals_dict``
+    namespace.
+
+    For example, ``pyomo/common/dependencies.py`` declares:
+
+    .. doctest::
+       :hide:
+
+       >>> from pyomo.common.dependencies import (
+       ...     attempt_import, _finalize_scipy, __dict__ as dep_globals,
+       ...     declare_modules_as_importable, )
+       >>> # Sphinx does not provide a proper globals()
+       >>> def globals(): return dep_globals
+
+    .. doctest::
+
+       >>> with declare_modules_as_importable(globals()):
+       ...     scipy, scipy_available = attempt_import(
+       ...        'scipy', callback=_finalize_scipy,
+       ...        deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'])
+
+    Which enables users to use:
+
+    .. doctest::
+
+       >>> import pyomo.common.dependencies.scipy.sparse as spa
+
+    If the deferred import has not yet been triggered, then the
+    :py:class:`DeferredImportModule` is returned and named ``spa``.
+    However, if the import has already been triggered, then ``spa`` will
+    either be the ``scipy.sparse`` module, or a
+    :py:class:`ModuleUnavailable` instance.
+
+    """
+
+    def __init__(self, globals_dict):
+        self.globals_dict = globals_dict
+        self.init_dict = {}
+        self.init_modules = None
+
+    def __enter__(self):
+        self.init_dict.update(self.globals_dict)
+        self.init_modules = set(sys.modules)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _global_name = self.globals_dict['__name__'] + '.'
+        deferred = {
+            k: v
+            for k, v in self.globals_dict.items()
+            if k not in self.init_dict
+            and isinstance(v, (ModuleType, DeferredImportModule))
+        }
+        if self.init_modules:
+            for name in set(sys.modules) - self.init_modules:
+                if '.' in name and name.split('.', 1)[0] in deferred:
+                    sys.modules[_global_name + name] = sys.modules[name]
+        while deferred:
+            name, mod = deferred.popitem()
+            mod.__path__ = None
+            mod.__spec__ = None
+            sys.modules[_global_name + name] = mod
+            if isinstance(mod, DeferredImportModule):
+                deferred.update(
+                    (name + '.' + k, v)
+                    for k, v in mod.__dict__.items()
+                    if type(v) is DeferredImportModule
+                )
 
 
 #
@@ -778,11 +963,18 @@ def _finalize_matplotlib(module, available):
     if in_testing_environment():
         module.use('Agg')
     import matplotlib.pyplot
+    import matplotlib.pylab
+    import matplotlib.backends
 
 
 def _finalize_numpy(np, available):
     if not available:
         return
+    # scipy has a dependence on numpy.testing, and if we don't import it
+    # as part of resolving numpy, then certain deferred scipy imports
+    # fail when run under pytest.
+    import numpy.testing
+
     from . import numeric_types
 
     # Register ndarray as a native type to prevent 1-element ndarrays
@@ -842,41 +1034,42 @@ def _pyutilib_importer():
     return importlib.import_module('pyutilib')
 
 
-# Standard libraries that are slower to import and not strictly required
-# on all platforms / situations.
-ctypes, _ = attempt_import(
-    'ctypes', deferred_submodules=['util'], callback=_finalize_ctypes
-)
-random, _ = attempt_import('random')
-
-# Commonly-used optional dependencies
-dill, dill_available = attempt_import('dill')
-mpi4py, mpi4py_available = attempt_import('mpi4py')
-networkx, networkx_available = attempt_import('networkx')
-numpy, numpy_available = attempt_import('numpy', callback=_finalize_numpy)
-pandas, pandas_available = attempt_import('pandas')
-plotly, plotly_available = attempt_import('plotly')
-pympler, pympler_available = attempt_import('pympler', callback=_finalize_pympler)
-pyutilib, pyutilib_available = attempt_import('pyutilib', importer=_pyutilib_importer)
-scipy, scipy_available = attempt_import(
-    'scipy',
-    callback=_finalize_scipy,
-    deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'],
-)
-yaml, yaml_available = attempt_import('yaml', callback=_finalize_yaml)
-
-# Note that matplotlib.pyplot can generate a runtime error on OSX when
-# not installed as a Framework (as is the case in the CI systems)
-matplotlib, matplotlib_available = attempt_import(
-    'matplotlib',
-    callback=_finalize_matplotlib,
-    deferred_submodules=['pyplot', 'pylab'],
-    catch_exceptions=(ImportError, RuntimeError),
-)
+with declare_modules_as_importable(globals()):
+    # Standard libraries that are slower to import and not strictly required
+    # on all platforms / situations.
+    ctypes, _ = attempt_import(
+        'ctypes', deferred_submodules=['util'], callback=_finalize_ctypes
+    )
+    random, _ = attempt_import('random')
+
+    # Commonly-used optional dependencies
+    dill, dill_available = attempt_import('dill')
+    mpi4py, mpi4py_available = attempt_import('mpi4py')
+    networkx, networkx_available = attempt_import('networkx')
+    numpy, numpy_available = attempt_import('numpy', callback=_finalize_numpy)
+    pandas, pandas_available = attempt_import('pandas')
+    plotly, plotly_available = attempt_import('plotly')
+    pympler, pympler_available = attempt_import('pympler', callback=_finalize_pympler)
+    pyutilib, pyutilib_available = attempt_import(
+        'pyutilib', importer=_pyutilib_importer
+    )
+    scipy, scipy_available = attempt_import(
+        'scipy',
+        callback=_finalize_scipy,
+        deferred_submodules=['stats', 'sparse', 'spatial', 'integrate'],
+    )
+    yaml, yaml_available = attempt_import('yaml', callback=_finalize_yaml)
+
+    # Note that matplotlib.pyplot can generate a runtime error on OSX when
+    # not installed as a Framework (as is the case in the CI systems)
+    matplotlib, matplotlib_available = attempt_import(
+        'matplotlib',
+        callback=_finalize_matplotlib,
+        deferred_submodules=['pyplot', 'pylab', 'backends'],
+        catch_exceptions=(ImportError, RuntimeError),
+    )
 
 try:
     import cPickle as pickle
 except ImportError:
     import pickle
-
-declare_deferred_modules_as_importable(globals())
diff --git a/pyomo/common/numeric_types.py b/pyomo/common/numeric_types.py
index ba104203667..ca2ce0f9c6c 100644
--- a/pyomo/common/numeric_types.py
+++ b/pyomo/common/numeric_types.py
@@ -12,7 +12,6 @@
 import logging
 import sys
 
-from pyomo.common.dependencies import numpy_available
 from pyomo.common.deprecation import deprecated, relocated_module_attribute
 from pyomo.common.errors import TemplateExpressionError
 
@@ -208,13 +207,6 @@ def check_if_numeric_type(obj):
     if obj_class in native_types:
         return obj_class in native_numeric_types
 
-    if 'numpy' in obj_class.__module__:
-        # trigger the resolution of numpy_available and check if this
-        # type was automatically registered
-        bool(numpy_available)
-        if obj_class in native_types:
-            return obj_class in native_numeric_types
-
     try:
         obj_plus_0 = obj + 0
         obj_p0_class = obj_plus_0.__class__
diff --git a/pyomo/common/tests/dep_mod.py b/pyomo/common/tests/dep_mod.py
index f6add596ed4..34c7219c6eb 100644
--- a/pyomo/common/tests/dep_mod.py
+++ b/pyomo/common/tests/dep_mod.py
@@ -13,8 +13,8 @@
 
 __version__ = '1.5'
 
-numpy, numpy_available = attempt_import('numpy', defer_check=True)
+numpy, numpy_available = attempt_import('numpy', defer_import=True)
 
 bogus_nonexisting_module, bogus_nonexisting_module_available = attempt_import(
-    'bogus_nonexisting_module', alt_names=['bogus_nem'], defer_check=True
+    'bogus_nonexisting_module', alt_names=['bogus_nem'], defer_import=True
 )
diff --git a/pyomo/common/tests/deps.py b/pyomo/common/tests/deps.py
index d00281553f4..5f8c1fffdf8 100644
--- a/pyomo/common/tests/deps.py
+++ b/pyomo/common/tests/deps.py
@@ -23,15 +23,16 @@
     bogus_nonexisting_module_available as has_bogus_nem,
 )
 
-bogus, bogus_available = attempt_import('nonexisting.module.bogus', defer_check=True)
+bogus, bogus_available = attempt_import('nonexisting.module.bogus', defer_import=True)
 
 pkl_test, pkl_available = attempt_import(
-    'nonexisting.module.pickle_test', deferred_submodules=['submod'], defer_check=True
+    'nonexisting.module.pickle_test', deferred_submodules=['submod'], defer_import=True
 )
 
 pyo, pyo_available = attempt_import(
     'pyomo',
     alt_names=['pyo'],
+    defer_import=True,
     deferred_submodules={'version': None, 'common.tests.dep_mod': ['dm']},
 )
 
diff --git a/pyomo/common/tests/test_dependencies.py b/pyomo/common/tests/test_dependencies.py
index 30822a4f81f..31f9520b613 100644
--- a/pyomo/common/tests/test_dependencies.py
+++ b/pyomo/common/tests/test_dependencies.py
@@ -45,7 +45,7 @@ def test_import_error(self):
         module_obj, module_available = attempt_import(
             '__there_is_no_module_named_this__',
             'Testing import of a non-existent module',
-            defer_check=False,
+            defer_import=False,
         )
         self.assertFalse(module_available)
         with self.assertRaisesRegex(
@@ -85,7 +85,7 @@ def test_pickle(self):
 
     def test_import_success(self):
         module_obj, module_available = attempt_import(
-            'ply', 'Testing import of ply', defer_check=False
+            'ply', 'Testing import of ply', defer_import=False
         )
         self.assertTrue(module_available)
         import ply
@@ -123,7 +123,7 @@ def test_imported_deferred_import(self):
 
     def test_min_version(self):
         mod, avail = attempt_import(
-            'pyomo.common.tests.dep_mod', minimum_version='1.0', defer_check=False
+            'pyomo.common.tests.dep_mod', minimum_version='1.0', defer_import=False
         )
         self.assertTrue(avail)
         self.assertTrue(inspect.ismodule(mod))
@@ -131,7 +131,7 @@ def test_min_version(self):
         self.assertFalse(check_min_version(mod, '2.0'))
 
         mod, avail = attempt_import(
-            'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_check=False
+            'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_import=False
         )
         self.assertFalse(avail)
         self.assertIs(type(mod), ModuleUnavailable)
@@ -146,7 +146,7 @@ def test_min_version(self):
             'pyomo.common.tests.dep_mod',
             error_message="Failed import",
             minimum_version='2.0',
-            defer_check=False,
+            defer_import=False,
         )
         self.assertFalse(avail)
         self.assertIs(type(mod), ModuleUnavailable)
@@ -159,10 +159,10 @@ def test_min_version(self):
 
         # Verify check_min_version works with deferred imports
 
-        mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+        mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
         self.assertTrue(check_min_version(mod, '1.0'))
 
-        mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+        mod, avail = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
         self.assertFalse(check_min_version(mod, '2.0'))
 
         # Verify check_min_version works when called directly
@@ -174,10 +174,10 @@ def test_min_version(self):
         self.assertFalse(check_min_version(mod, '1.0'))
 
     def test_and_or(self):
-        mod0, avail0 = attempt_import('ply', defer_check=True)
-        mod1, avail1 = attempt_import('pyomo.common.tests.dep_mod', defer_check=True)
+        mod0, avail0 = attempt_import('ply', defer_import=True)
+        mod1, avail1 = attempt_import('pyomo.common.tests.dep_mod', defer_import=True)
         mod2, avail2 = attempt_import(
-            'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_check=True
+            'pyomo.common.tests.dep_mod', minimum_version='2.0', defer_import=True
         )
 
         _and = avail0 & avail1
@@ -233,11 +233,11 @@ def test_callbacks(self):
         def _record_avail(module, avail):
             ans.append(avail)
 
-        mod0, avail0 = attempt_import('ply', defer_check=True, callback=_record_avail)
+        mod0, avail0 = attempt_import('ply', defer_import=True, callback=_record_avail)
         mod1, avail1 = attempt_import(
             'pyomo.common.tests.dep_mod',
             minimum_version='2.0',
-            defer_check=True,
+            defer_import=True,
             callback=_record_avail,
         )
 
@@ -250,7 +250,7 @@ def _record_avail(module, avail):
     def test_import_exceptions(self):
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod_except',
-            defer_check=True,
+            defer_import=True,
             only_catch_importerror=True,
         )
         with self.assertRaisesRegex(ValueError, "cannot import module"):
@@ -260,7 +260,7 @@ def test_import_exceptions(self):
 
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod_except',
-            defer_check=True,
+            defer_import=True,
             only_catch_importerror=False,
         )
         self.assertFalse(avail)
@@ -268,7 +268,7 @@ def test_import_exceptions(self):
 
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod_except',
-            defer_check=True,
+            defer_import=True,
             catch_exceptions=(ImportError, ValueError),
         )
         self.assertFalse(avail)
@@ -280,7 +280,7 @@ def test_import_exceptions(self):
         ):
             mod, avail = attempt_import(
                 'pyomo.common.tests.dep_mod_except',
-                defer_check=True,
+                defer_import=True,
                 only_catch_importerror=True,
                 catch_exceptions=(ImportError,),
             )
@@ -288,7 +288,7 @@ def test_import_exceptions(self):
     def test_generate_warning(self):
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod_except',
-            defer_check=True,
+            defer_import=True,
             only_catch_importerror=False,
         )
 
@@ -324,7 +324,7 @@ def test_generate_warning(self):
     def test_log_warning(self):
         mod, avail = attempt_import(
             'pyomo.common.tests.dep_mod_except',
-            defer_check=True,
+            defer_import=True,
             only_catch_importerror=False,
         )
         log = StringIO()
@@ -366,9 +366,9 @@ def test_importer(self):
 
         def _importer():
             attempted_import.append(True)
-            return attempt_import('pyomo.common.tests.dep_mod', defer_check=False)[0]
+            return attempt_import('pyomo.common.tests.dep_mod', defer_import=False)[0]
 
-        mod, avail = attempt_import('foo', importer=_importer, defer_check=True)
+        mod, avail = attempt_import('foo', importer=_importer, defer_import=True)
 
         self.assertEqual(attempted_import, [])
         self.assertIsInstance(mod, DeferredImportModule)
@@ -401,17 +401,17 @@ def test_deferred_submodules(self):
         self.assertTrue(inspect.ismodule(deps.dm))
 
         with self.assertRaisesRegex(
-            ValueError, "deferred_submodules is only valid if defer_check==True"
+            ValueError, "deferred_submodules is only valid if defer_import==True"
         ):
             mod, mod_available = attempt_import(
                 'nonexisting.module',
-                defer_check=False,
+                defer_import=False,
                 deferred_submodules={'submod': None},
             )
 
         mod, mod_available = attempt_import(
             'nonexisting.module',
-            defer_check=True,
+            defer_import=True,
             deferred_submodules={'submod.subsubmod': None},
         )
         self.assertIs(type(mod), DeferredImportModule)
@@ -427,7 +427,7 @@ def test_UnavailableClass(self):
         module_obj, module_available = attempt_import(
             '__there_is_no_module_named_this__',
             'Testing import of a non-existent module',
-            defer_check=False,
+            defer_import=False,
         )
 
         class A_Class(UnavailableClass(module_obj)):
diff --git a/pyomo/common/unittest.py b/pyomo/common/unittest.py
index 9ee7731bda4..84d962eb784 100644
--- a/pyomo/common/unittest.py
+++ b/pyomo/common/unittest.py
@@ -635,7 +635,7 @@ def initialize_dependencies(self):
         cls.package_modules = {}
         packages_used = set(sum(list(cls.package_dependencies.values()), []))
         for package_ in packages_used:
-            pack, pack_avail = attempt_import(package_, defer_check=False)
+            pack, pack_avail = attempt_import(package_, defer_import=False)
             cls.package_available[package_] = pack_avail
             cls.package_modules[package_] = pack
 
diff --git a/pyomo/contrib/pynumero/dependencies.py b/pyomo/contrib/pynumero/dependencies.py
index 9e2088ffa0a..d323bd43e84 100644
--- a/pyomo/contrib/pynumero/dependencies.py
+++ b/pyomo/contrib/pynumero/dependencies.py
@@ -17,7 +17,7 @@
     'numpy',
     'Pynumero requires the optional Pyomo dependency "numpy"',
     minimum_version='1.13.0',
-    defer_check=False,
+    defer_import=False,
 )
 
 if not numpy_available:
diff --git a/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py b/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
index 1f45f26d43b..408a0197382 100644
--- a/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
+++ b/pyomo/contrib/pynumero/examples/tests/test_cyipopt_examples.py
@@ -35,7 +35,7 @@
     'One of the tests below requires a recent version of pandas for'
     ' comparing with a tolerance.',
     minimum_version='1.1.0',
-    defer_check=False,
+    defer_import=False,
 )
 
 from pyomo.contrib.pynumero.asl import AmplInterface
diff --git a/pyomo/contrib/pynumero/intrinsic.py b/pyomo/contrib/pynumero/intrinsic.py
index 84675cc4c02..34054e7ffa2 100644
--- a/pyomo/contrib/pynumero/intrinsic.py
+++ b/pyomo/contrib/pynumero/intrinsic.py
@@ -11,9 +11,7 @@
 
 from pyomo.common.dependencies import numpy as np, attempt_import
 
-block_vector = attempt_import(
-    'pyomo.contrib.pynumero.sparse.block_vector', defer_check=True
-)[0]
+block_vector = attempt_import('pyomo.contrib.pynumero.sparse.block_vector')[0]
 
 
 def norm(x, ord=None):
diff --git a/pyomo/core/base/units_container.py b/pyomo/core/base/units_container.py
index 1bf25ffdead..fb3d28385d0 100644
--- a/pyomo/core/base/units_container.py
+++ b/pyomo/core/base/units_container.py
@@ -127,7 +127,6 @@
 
 pint_module, pint_available = attempt_import(
     'pint',
-    defer_check=True,
     error_message=(
         'The "pint" package failed to import. '
         'This package is necessary to use Pyomo units.'
diff --git a/pyomo/core/tests/unit/test_numvalue.py b/pyomo/core/tests/unit/test_numvalue.py
index bd784d655e8..1cccd3863ea 100644
--- a/pyomo/core/tests/unit/test_numvalue.py
+++ b/pyomo/core/tests/unit/test_numvalue.py
@@ -18,6 +18,7 @@
 
 import pyomo.common.unittest as unittest
 from pyomo.common.dependencies import numpy, numpy_available
+from pyomo.core.base.units_container import pint_available
 
 from pyomo.environ import (
     value,
@@ -50,7 +51,16 @@ def __init__(self, val=0):
 
 class MyBogusNumericType(MyBogusType):
     def __add__(self, other):
-        return MyBogusNumericType(self.val + float(other))
+        if other.__class__ in native_numeric_types:
+            return MyBogusNumericType(self.val + float(other))
+        else:
+            return NotImplemented
+
+    def __le__(self, other):
+        if other.__class__ in native_numeric_types:
+            return self.val <= float(other)
+        else:
+            return NotImplemented
 
     def __lt__(self, other):
         return self.val < float(other)
@@ -534,6 +544,8 @@ def test_unknownNumericType(self):
         try:
             val = as_numeric(ref)
             self.assertEqual(val().val, 42.0)
+            self.assertIn(MyBogusNumericType, native_numeric_types)
+            self.assertIn(MyBogusNumericType, native_types)
         finally:
             native_numeric_types.remove(MyBogusNumericType)
             native_types.remove(MyBogusNumericType)
@@ -562,10 +574,43 @@ def test_numpy_basic_bool_registration(self):
     @unittest.skipUnless(numpy_available, "This test requires NumPy")
     def test_automatic_numpy_registration(self):
         cmd = (
-            'import pyomo; from pyomo.core.base import Var, Param; '
-            'from pyomo.core.base.units_container import units; import numpy as np; '
-            'print(np.float64 in pyomo.common.numeric_types.native_numeric_types); '
-            '%s; print(np.float64 in pyomo.common.numeric_types.native_numeric_types)'
+            'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+            'print("float64" in [_.__name__ for _ in nnt]); '
+            'import numpy; '
+            'print("float64" in [_.__name__ for _ in nnt])'
+        )
+
+        rc = subprocess.run(
+            [sys.executable, '-c', cmd],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        self.assertEqual((rc.returncode, rc.stdout), (0, "False\nTrue\n"))
+
+        cmd = (
+            'import numpy; '
+            'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+            'print("float64" in [_.__name__ for _ in nnt])'
+        )
+
+        rc = subprocess.run(
+            [sys.executable, '-c', cmd],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        self.assertEqual((rc.returncode, rc.stdout), (0, "True\n"))
+
+    def test_unknownNumericType_expr_registration(self):
+        cmd = (
+            'import pyomo; '
+            'from pyomo.core.base import Var, Param; '
+            'from pyomo.core.base.units_container import units; '
+            'from pyomo.common.numeric_types import native_numeric_types as nnt; '
+            f'from {__name__} import MyBogusNumericType; '
+            'ref = MyBogusNumericType(42); '
+            'print(MyBogusNumericType in nnt); %s; print(MyBogusNumericType in nnt); '
         )
 
         def _tester(expr):
@@ -575,19 +620,32 @@ def _tester(expr):
                 stderr=subprocess.STDOUT,
                 text=True,
             )
-            self.assertEqual((rc.returncode, rc.stdout), (0, "False\nTrue\n"))
-
-        _tester('Var() <= np.float64(5)')
-        _tester('np.float64(5) <= Var()')
-        _tester('np.float64(5) + Var()')
-        _tester('Var() + np.float64(5)')
-        _tester('v = Var(); v.construct(); v.value = np.float64(5)')
-        _tester('p = Param(mutable=True); p.construct(); p.value = np.float64(5)')
-        _tester('v = Var(units=units.m); v.construct(); v.value = np.float64(5)')
-        _tester(
-            'p = Param(mutable=True, units=units.m); p.construct(); '
-            'p.value = np.float64(5)'
-        )
+            self.assertEqual(
+                (rc.returncode, rc.stdout),
+                (
+                    0,
+                    '''False
+WARNING: Dynamically registering the following numeric type:
+        pyomo.core.tests.unit.test_numvalue.MyBogusNumericType
+    Dynamic registration is supported for convenience, but there are known
+    limitations to this approach.  We recommend explicitly registering numeric
+    types using RegisterNumericType() or RegisterIntegerType().
+True
+''',
+                ),
+            )
+
+        _tester('Var() <= ref')
+        _tester('ref <= Var()')
+        _tester('ref + Var()')
+        _tester('Var() + ref')
+        _tester('v = Var(); v.construct(); v.value = ref')
+        _tester('p = Param(mutable=True); p.construct(); p.value = ref')
+        if pint_available:
+            _tester('v = Var(units=units.m); v.construct(); v.value = ref')
+            _tester(
+                'p = Param(mutable=True, units=units.m); p.construct(); p.value = ref'
+            )
 
 
 if __name__ == "__main__":
diff --git a/pyomo/solvers/plugins/solvers/GAMS.py b/pyomo/solvers/plugins/solvers/GAMS.py
index e84cbdb441d..be3499a2f6b 100644
--- a/pyomo/solvers/plugins/solvers/GAMS.py
+++ b/pyomo/solvers/plugins/solvers/GAMS.py
@@ -41,7 +41,7 @@
 
 from pyomo.common.dependencies import attempt_import
 
-gdxcc, gdxcc_available = attempt_import('gdxcc', defer_check=True)
+gdxcc, gdxcc_available = attempt_import('gdxcc')
 
 logger = logging.getLogger('pyomo.solvers')