From: Mike Bayer Date: Wed, 7 Oct 2020 01:46:03 +0000 (-0400) Subject: Use preloaded for sql.util import in exc X-Git-Tag: rel_1_4_0b1~56 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=f3268b6f2fa5ac7023f656caa085316fa46b24e9;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git 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 --- diff --git a/doc/build/changelog/unreleased_13/5632.rst b/doc/build/changelog/unreleased_13/5632.rst new file mode 100644 index 0000000000..fb906944ee --- /dev/null +++ b/doc/build/changelog/unreleased_13/5632.rst @@ -0,0 +1,7 @@ +.. change:: + :tags: bug, engine + :tickets: 5632 + + Repaired a function-level import that was not using SQLAlchemy's standard + late-import system within the sqlalchemy.exc module. + diff --git a/lib/sqlalchemy/exc.py b/lib/sqlalchemy/exc.py index 7e4a3f53eb..7ba2e369b6 100644 --- a/lib/sqlalchemy/exc.py +++ b/lib/sqlalchemy/exc.py @@ -13,6 +13,7 @@ raised as a result of DBAPI exceptions are all subclasses of """ +from .util import _preloaded from .util import compat _version_token = None @@ -416,8 +417,9 @@ class StatementError(SQLAlchemyError): ), ) + @_preloaded.preload_module("sqlalchemy.sql.util") def _sql_message(self, as_unicode): - from sqlalchemy.sql import util + util = _preloaded.preloaded.sql_util details = [self._message(as_unicode=as_unicode)] if self.statement: diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py index 7ce0ce12bb..8ef2f01032 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 0000000000..1a833a963c --- /dev/null +++ b/lib/sqlalchemy/util/_preloaded.py @@ -0,0 +1,62 @@ +# util/_preloaded.py +# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors +# +# +# 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 `_`, 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 85a065e999..e546f196d5 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 `_`, 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): diff --git a/test/base/test_utils.py b/test/base/test_utils.py index d765a46131..fa347243e7 100644 --- a/test/base/test_utils.py +++ b/test/base/test_utils.py @@ -24,6 +24,7 @@ from sqlalchemy.testing import mock from sqlalchemy.testing import ne_ from sqlalchemy.testing.util import gc_collect from sqlalchemy.testing.util import picklers +from sqlalchemy.util import _preloaded from sqlalchemy.util import classproperty from sqlalchemy.util import compat from sqlalchemy.util import get_callable_argspec @@ -3210,7 +3211,7 @@ class TestModuleRegistry(fixtures.TestBase): for m in ("xml.dom", "wsgiref.simple_server"): to_restore.append((m, sys.modules.pop(m, None))) try: - mr = langhelpers._ModuleRegistry() + mr = _preloaded._ModuleRegistry() ret = mr.preload_module( "xml.dom", "wsgiref.simple_server", "sqlalchemy.sql.util"