Use preloaded for sql.util import in exc

Repaired a function-level import that was not using SQLAlchemy's standard
late-import system within the sqlalchemy.exc module.

Moved preloaded to sqlalchemy.util.preloaded so that it
does not depend on langhelpers which depends on exc.

Fixes: #5632
Change-Id: I61b7ce9cd461071ce543714739f67aa5aeb47fd6

3 files changed, 64 insertions, 49 deletions

diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py
index 7ce0ce12b..8ef2f0103 100644
--- a/lib/sqlalchemy/util/__init__.py
+++ b/lib/sqlalchemy/util/__init__.py
@@ -44,6 +44,8 @@ from ._collections import UniqueAppender  # noqa
 from ._collections import update_copy  # noqa
 from ._collections import WeakPopulateDict  # noqa
 from ._collections import WeakSequence  # noqa
+from ._preloaded import preload_module  # noqa
+from ._preloaded import preloaded  # noqa
 from .compat import ABC  # noqa
 from .compat import arm  # noqa
 from .compat import b  # noqa
@@ -149,8 +151,6 @@ from .langhelpers import NoneType  # noqa
 from .langhelpers import only_once  # noqa
 from .langhelpers import PluginLoader  # noqa
 from .langhelpers import portable_instancemethod  # noqa
-from .langhelpers import preload_module  # noqa
-from .langhelpers import preloaded  # noqa
 from .langhelpers import quoted_token_parser  # noqa
 from .langhelpers import safe_reraise  # noqa
 from .langhelpers import set_creation_order  # noqa
diff --git a/lib/sqlalchemy/util/_preloaded.py b/lib/sqlalchemy/util/_preloaded.py
new file mode 100644
index 000000000..1a833a963
--- /dev/null
+++ b/lib/sqlalchemy/util/_preloaded.py
@@ -0,0 +1,62 @@
+# util/_preloaded.py
+# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""supplies the "preloaded" registry to resolve circular module imports at
+runtime.
+
+"""
+
+import sys
+
+from . import compat
+
+
+class _ModuleRegistry:
+    """Registry of modules to load in a package init file.
+
+    To avoid potential thread safety issues for imports that are deferred
+    in a function, like https://bugs.python.org/issue38884, these modules
+    are added to the system module cache by importing them after the packages
+    has finished initialization.
+
+    A global instance is provided under the name :attr:`.preloaded`. Use
+    the function :func:`.preload_module` to register modules to load and
+    :meth:`.import_prefix` to load all the modules that start with the
+    given path.
+
+    While the modules are loaded in the global module cache, it's advisable
+    to access them using :attr:`.preloaded` to ensure that it was actually
+    registered. Each registered module is added to the instance ``__dict__``
+    in the form `<package>_<module>`, omitting ``sqlalchemy`` from the package
+    name. Example: ``sqlalchemy.sql.util`` becomes ``preloaded.sql_util``.
+    """
+
+    def __init__(self, prefix="sqlalchemy"):
+        self.module_registry = set()
+
+    def preload_module(self, *deps):
+        """Adds the specified modules to the list to load.
+
+        This method can be used both as a normal function and as a decorator.
+        No change is performed to the decorated object.
+        """
+        self.module_registry.update(deps)
+        return lambda fn: fn
+
+    def import_prefix(self, path):
+        """Resolve all the modules in the registry that start with the
+        specified path.
+        """
+        for module in self.module_registry:
+            key = module.split("sqlalchemy.")[-1].replace(".", "_")
+            if module.startswith(path) and key not in self.__dict__:
+                compat.import_(module, globals(), locals())
+                self.__dict__[key] = sys.modules[module]
+
+
+preloaded = _ModuleRegistry()
+preload_module = preloaded.preload_module
diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py
index 85a065e99..e546f196d 100644
--- a/lib/sqlalchemy/util/langhelpers.py
+++ b/lib/sqlalchemy/util/langhelpers.py
@@ -1044,53 +1044,6 @@ class MemoizedSlots(object):
             return self._fallback_getattr(key)
 
 
-class _ModuleRegistry:
-    """Registry of modules to load in a package init file.
-
-    To avoid potential thread safety issues for imports that are deferred
-    in a function, like https://bugs.python.org/issue38884, these modules
-    are added to the system module cache by importing them after the packages
-    has finished initialization.
-
-    A global instance is provided under the name :attr:`.preloaded`. Use
-    the function :func:`.preload_module` to register modules to load and
-    :meth:`.import_prefix` to load all the modules that start with the
-    given path.
-
-    While the modules are loaded in the global module cache, it's advisable
-    to access them using :attr:`.preloaded` to ensure that it was actually
-    registered. Each registered module is added to the instance ``__dict__``
-    in the form `<package>_<module>`, omitting ``sqlalchemy`` from the package
-    name. Example: ``sqlalchemy.sql.util`` becomes ``preloaded.sql_util``.
-    """
-
-    def __init__(self, prefix="sqlalchemy"):
-        self.module_registry = set()
-
-    def preload_module(self, *deps):
-        """Adds the specified modules to the list to load.
-
-        This method can be used both as a normal function and as a decorator.
-        No change is performed to the decorated object.
-        """
-        self.module_registry.update(deps)
-        return lambda fn: fn
-
-    def import_prefix(self, path):
-        """Resolve all the modules in the registry that start with the
-        specified path.
-        """
-        for module in self.module_registry:
-            key = module.split("sqlalchemy.")[-1].replace(".", "_")
-            if module.startswith(path) and key not in self.__dict__:
-                compat.import_(module, globals(), locals())
-                self.__dict__[key] = sys.modules[module]
-
-
-preloaded = _ModuleRegistry()
-preload_module = preloaded.preload_module
-
-
 # from paste.deploy.converters
 def asbool(obj):
     if isinstance(obj, compat.string_types):