Mercurial > hg
view hgdemandimport/demandimportpy3.py @ 44651:00e0c5c06ed5
pycompat: change argv conversion semantics
Use of os.fsencode() to convert Python's sys.argv back to bytes
was not correct because it isn't the logically inverse operation
from what CPython was doing under the hood.
This commit changes the logic for doing the str -> bytes
conversion. This required a separate implementation for
POSIX and Windows.
The Windows behavior is arguably not ideal. The previous
behavior on Windows was leading to failing tests, such as
test-http-branchmap.t, which defines a utf-8 branch name
via a command argument. Previously, Mercurial's argument
parser looked to be receiving wchar_t bytes in some cases.
After this commit, behavior on Windows is compatible with
Python 2, where CPython did not implement `int wmain()` and
Windows was performing a Unicode to ANSI conversion on the
wchar_t native command line.
Arguably better behavior on Windows would be for Mercurial to
preserve the original Unicode sequence coming from Python and
to wrap this in a bytes-like type so we can round trip safely.
But, this would be new, backwards incompatible behavior. My
goal for this commit was to converge Mercurial behavior on
Python 3 on Windows to fix busted tests. And I believe I was
successful, as this commit fixes 9 tests on my Windows
machine and 14 tests in the AWS CI environment!
Differential Revision: https://phab.mercurial-scm.org/D8337
author | Gregory Szorc <gregory.szorc@gmail.com> |
---|---|
date | Sat, 28 Mar 2020 12:18:58 -0700 |
parents | f81c17ec303c |
children | a6e12d477595 |
line wrap: on
line source
# demandimportpy3 - global demand-loading of modules for Mercurial # # Copyright 2017 Facebook Inc. # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. """Lazy loading for Python 3.6 and above. This uses the new importlib finder/loader functionality available in Python 3.5 and up. The code reuses most of the mechanics implemented inside importlib.util, but with a few additions: * Allow excluding certain modules from lazy imports. * Expose an interface that's substantially the same as demandimport for Python 2. This also has some limitations compared to the Python 2 implementation: * Much of the logic is per-package, not per-module, so any packages loaded before demandimport is enabled will not be lazily imported in the future. In practice, we only expect builtins to be loaded before demandimport is enabled. """ # This line is unnecessary, but it satisfies test-check-py3-compat.t. from __future__ import absolute_import import contextlib import importlib.util import sys from . import tracing _deactivated = False # Python 3.5's LazyLoader doesn't work for some reason. # https://bugs.python.org/issue26186 is a known issue with extension # importing. But it appears to not have a meaningful effect with # Mercurial. _supported = sys.version_info[0:2] >= (3, 6) class _lazyloaderex(importlib.util.LazyLoader): """This is a LazyLoader except it also follows the _deactivated global and the ignore list. """ def exec_module(self, module): """Make the module load lazily.""" with tracing.log('demandimport %s', module): if _deactivated or module.__name__ in ignores: self.loader.exec_module(module) else: super().exec_module(module) class LazyFinder(object): """A wrapper around a ``MetaPathFinder`` that makes loaders lazy. ``sys.meta_path`` finders have their ``find_spec()`` called to locate a module. This returns a ``ModuleSpec`` if found or ``None``. The ``ModuleSpec`` has a ``loader`` attribute, which is called to actually load a module. Our class wraps an existing finder and overloads its ``find_spec()`` to replace the ``loader`` with our lazy loader proxy. We have to use __getattribute__ to proxy the instance because some meta path finders don't support monkeypatching. """ __slots__ = ("_finder",) def __init__(self, finder): object.__setattr__(self, "_finder", finder) def __repr__(self): return "<LazyFinder for %r>" % object.__getattribute__(self, "_finder") # __bool__ is canonical Python 3. But check-code insists on __nonzero__ being # defined via `def`. def __nonzero__(self): return bool(object.__getattribute__(self, "_finder")) __bool__ = __nonzero__ def __getattribute__(self, name): if name in ("_finder", "find_spec"): return object.__getattribute__(self, name) return getattr(object.__getattribute__(self, "_finder"), name) def __delattr__(self, name): return delattr(object.__getattribute__(self, "_finder")) def __setattr__(self, name, value): return setattr(object.__getattribute__(self, "_finder"), name, value) def find_spec(self, *args, **kwargs): finder = object.__getattribute__(self, "_finder") spec = finder.find_spec(*args, **kwargs) # Lazy loader requires exec_module(). if ( spec is not None and spec.loader is not None and getattr(spec.loader, "exec_module") ): spec.loader = _lazyloaderex(spec.loader) return spec ignores = set() def init(ignoreset): global ignores ignores = ignoreset def isenabled(): return not _deactivated and any( isinstance(finder, LazyFinder) for finder in sys.meta_path ) def disable(): new_finders = [] for finder in sys.meta_path: new_finders.append( finder._finder if isinstance(finder, LazyFinder) else finder ) sys.meta_path[:] = new_finders def enable(): if not _supported: return new_finders = [] for finder in sys.meta_path: new_finders.append( LazyFinder(finder) if not isinstance(finder, LazyFinder) else finder ) sys.meta_path[:] = new_finders @contextlib.contextmanager def deactivated(): # This implementation is a bit different from Python 2's. Python 3 # maintains a per-package finder cache in sys.path_importer_cache (see # PEP 302). This means that we can't just call disable + enable. # If we do that, in situations like: # # demandimport.enable() # ... # from foo.bar import mod1 # with demandimport.deactivated(): # from foo.bar import mod2 # # mod2 will be imported lazily. (The converse also holds -- whatever finder # first gets cached will be used.) # # Instead, have a global flag the LazyLoader can use. global _deactivated demandenabled = isenabled() if demandenabled: _deactivated = True try: yield finally: if demandenabled: _deactivated = False