path: root/library/python/runtime/importer.pxi

import copy
import imp
import importlib
import marshal
import os
import re
import sys
import traceback
from os.path import sep as path_sep

import __res as __resource

env_entry_point = 'Y_PYTHON_ENTRY_POINT'
env_source_root = 'Y_PYTHON_SOURCE_ROOT'
executable = sys.executable or 'Y_PYTHON'
sys.modules['run_import_hook'] = __resource

find_py_module = lambda mod: __resource.find('/py_modules/' + mod)
find_py_code = lambda mod: __resource.find('/py_code/' + mod)

Y_PYTHON_SOURCE_ROOT = os.environ.get(env_source_root)
if Y_PYTHON_SOURCE_ROOT is not None:
    Y_PYTHON_SOURCE_ROOT = os.path.abspath(os.path.expanduser(Y_PYTHON_SOURCE_ROOT))
    os.environ[env_source_root] = Y_PYTHON_SOURCE_ROOT


def file_bytes(path):
    with open(path, 'rb') as f:
        return f.read()


def iter_keys(prefix):
    l = len(prefix)
    for idx in xrange(__resource.count()):
        key = __resource.key_by_index(idx)
        if key.startswith(prefix):
            yield key, key[l:]


def iter_py_modules(with_keys=False):
    for key, mod in iter_keys('/py_modules/'):
        if '/' in mod:
            raise Exception('Incorrect py_modules resource: ' + repr(key))
        if with_keys:
            yield key, mod
        else:
            yield mod


def iter_prefixes(s):
    i = s.find('.')
    while i >= 0:
        yield s[:i]
        i = s.find('.', i + 1)


def resfs_resolve(path):
    """
    Return the absolute path of a root-relative path if it exists.
    """
    if Y_PYTHON_SOURCE_ROOT:
        abspath = os.path.join(Y_PYTHON_SOURCE_ROOT, path)
        if os.path.exists(abspath):
            return abspath


def resfs_src(key, resfs_file=False):
    """
    Return the root-relative file path of a resource key.
    """
    if resfs_file:
        key = 'resfs/file/' + key
    return __resource.find('resfs/src/' + key)


def resfs_read(path, builtin=None):
    """
    Return the bytes of the resource file at path, or None.
    If builtin is True, do not look for it on the filesystem.
    If builtin is False, do not look in the builtin resources.
    """
    if builtin is not True:
        arcpath = resfs_src(path, resfs_file=True)
        if arcpath:
            fspath = resfs_resolve(arcpath)
            if fspath:
                return file_bytes(fspath)

    if builtin is not False:
        return __resource.find('resfs/file/' + path)


def resfs_files(prefix=''):
    """
    List builtin resource file paths.
    """
    return [key[11:] for key, _ in iter_keys('resfs/file/' + prefix)]


class ResourceImporter(object):

    """ A meta_path importer that loads code from built-in resources.
    """

    def __init__(self):
        self.memory = set(iter_py_modules())  # Set of importable module names.
        self.source_map = {}                  # Map from file names to module names.
        self._source_name = {}                # Map from original to altered module names.
        self._package_prefix = ''

        self._before_import_callback = None
        self._after_import_callback = None

        for p in list(self.memory) + list(sys.builtin_module_names):
            for pp in iter_prefixes(p):
                k = pp + '.__init__'
                if k not in self.memory:
                    self.memory.add(k)

    def for_package(self, name):
        importer = copy.copy(self)
        importer._package_prefix = name + '.'
        return importer

    def set_callbacks(self, before_import=None, after_import=None):
        """Callable[[module], None]"""
        self._before_import_callback = before_import
        self._after_import_callback = after_import

    # PEP-302 finder.
    def find_module(self, fullname, path=None):
        try:
            self.is_package(fullname)
        except ImportError:
            return None
        return self

    # PEP-302 extension 1 of 3: data loader.
    def get_data(self, path):
        abspath = resfs_resolve(path)
        if abspath:
            return file_bytes(abspath)
        path = path.replace('\\', '/')
        data = resfs_read(path, builtin=True)
        if data is None:
            raise IOError(path)  # Y_PYTHON_ENTRY_POINT=:resource_files
        return data

    # PEP-302 extension 2 of 3: get __file__ without importing.
    def get_filename(self, fullname):
        modname = fullname
        if self.is_package(fullname):
            fullname += '.__init__'
        return resfs_src('/py_modules/' + fullname) or modname

    # PEP-302 extension 3 of 3: packaging introspection.
    # Used by `linecache` (while printing tracebacks) unless module filename
    # exists on the filesystem.
    def get_source(self, fullname):
        fullname = self._source_name.get(fullname, fullname)
        if self.is_package(fullname):
            fullname += '.__init__'

        abspath = resfs_resolve(self.get_filename(fullname))
        if abspath:
            return file_bytes(abspath)
        return find_py_module(fullname)

    def get_code(self, fullname):
        modname = fullname
        if self.is_package(fullname):
            fullname += '.__init__'

        abspath = resfs_resolve(self.get_filename(fullname))
        if abspath:
            data = file_bytes(abspath)
            return compile(data, abspath, 'exec', dont_inherit=True)

        pyc = find_py_code(fullname)
        if pyc:
            return marshal.loads(pyc)
        else:
            # This covers packages with no __init__.py in resources.
            return compile('', modname, 'exec', dont_inherit=True)

    def is_package(self, fullname):
        if fullname in self.memory:
            return False

        if fullname + '.__init__' in self.memory:
            return True

        raise ImportError(fullname)

    # Extension for contrib/python/coverage.
    def file_source(self, filename):
        """
        Return the key of the module source by its resource path.
        """
        if not self.source_map:
            for key, mod in iter_py_modules(with_keys=True):
                path = self.get_filename(mod)
                self.source_map[path] = key

        if filename in self.source_map:
            return self.source_map[filename]

        if resfs_read(filename, builtin=True) is not None:
            return 'resfs/file/' + filename

        return ''

    # Extension for pkgutil.iter_modules.
    def iter_modules(self, prefix=''):
        rx = re.compile(re.escape(self._package_prefix) + r'([^.]+)(\.__init__)?$')
        for p in self.memory:
            m = rx.match(p)
            if m:
                yield prefix + m.group(1), m.group(2) is not None

    # PEP-302 loader.
    def load_module(self, mod_name, fix_name=None):
        code = self.get_code(mod_name)
        is_package = self.is_package(mod_name)
        source_name = self._source_name

        mod = imp.new_module(mod_name)
        mod.__loader__ = self
        mod.__file__ = code.co_filename

        if is_package:
            mod.__path__ = [executable + path_sep + mod_name.replace('.', path_sep)]
            mod.__package__ = mod_name
        else:
            mod.__package__ = mod_name.rpartition('.')[0]

        if fix_name:
            mod.__name__ = fix_name
            self._source_name = dict(source_name, **{fix_name: mod_name})

        old_mod = sys.modules.get(mod_name, None)
        sys.modules[mod_name] = mod

        # __name__ and __file__ could be overwritten after execution
        # So these two things are needed if wee want to be consistent at some point
        initial_modname = mod.__name__
        initial_filename = mod.__file__

        if self._before_import_callback:
            self._before_import_callback(initial_modname, initial_filename)

        try:
            exec code in mod.__dict__
            old_mod = sys.modules[mod_name]
        finally:
            sys.modules[mod_name] = old_mod

            # "Zero-cost". Just in case import error occurs
            if self._after_import_callback:
                self._after_import_callback(initial_modname, initial_filename)

        # Some hacky modules (e.g. pygments.lexers) replace themselves in
        # `sys.modules` with proxies.
        return sys.modules[mod_name]

    def run_main(self):
        entry_point = os.environ.pop(env_entry_point, None)

        if entry_point is None:
            entry_point = __resource.find('PY_MAIN')

        if entry_point is None:
            entry_point = '__main__'

        if ':' in entry_point:
            mod_name, func_name = entry_point.split(':', 1)
            if mod_name == '':
                mod_name = 'library.python.runtime.entry_points'
            mod = importlib.import_module(mod_name)
            func = getattr(mod, func_name)
            return func()

        if entry_point not in self.memory:
            raise Exception(entry_point + ' not found')

        self.load_module(entry_point, fix_name='__main__')


importer = ResourceImporter()
sys.meta_path.insert(0, importer)


def executable_path_hook(path):
    if path == executable:
        return importer

    if path.startswith(executable + path_sep):
        return importer.for_package(path[len(executable + path_sep):].replace(path_sep, '.'))

    raise ImportError(path)


if executable not in sys.path:
    sys.path.insert(0, executable)
sys.path_hooks.insert(0, executable_path_hook)
sys.path_importer_cache[executable] = importer

# Indicator that modules and resources are built-in rather than on the file system.
sys.is_standalone_binary = True
sys.frozen = True

# Set of names of importable modules.
sys.extra_modules = importer.memory

# Use pure-python implementation of traceback printer.
# Built-in printer (PyTraceBack_Print) does not support custom module loaders
sys.excepthook = traceback.print_exception