--- /dev/null
+.. 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.
+
"""
+from .util import _preloaded
from .util import compat
_version_token = None
),
)
+ @_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:
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
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
--- /dev/null
+# 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
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):
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
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"
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
