def makeImportedModule(name, pathname, desc, scope):

    def _loadModule():
        """ Load the given module, and insert it into the parent
            scope, and also the original importing scope.
        """

        mod = sys.modules.get(name, None)
        if mod is None or not isinstance(mod, types.ModuleType):
            try:
                file = open(pathname, 'U')
            except:
                file = None

            try:
                mod = imp.load_module(name, file, pathname, desc)
            finally:
                if file is not None:
                    file.close()

            sys.modules[name] = mod

        scope[name] = mod

        frame = sys._getframe(2)
        global_scope = frame.f_globals
        local_scope = frame.f_locals

        # check to see if this module exists for any part of the name
        # we are importing, e.g. if you are importing foo.bar.baz,
        # look for foo.bar.baz, bar.baz, and baz.
        moduleParts = name.split('.')
        names = [ '.'.join(moduleParts[-x:]) for x in range(len(moduleParts)) ]
        for modulePart in names:
            if modulePart in local_scope:
                if (hasattr(local_scope[modulePart], '__class__')
                    and local_scope[modulePart].__class__.__name__ == 'ModuleProxy'):
                    # FIXME: this makes me cringe, but I haven't figured out a
                    # better way to ensure that the module proxy we're
                    # looking at is actually a proxy for this module
                    if pathname in repr(local_scope[modulePart]):
                        local_scope[modulePart] = mod
            if modulePart in global_scope:
                if (hasattr(global_scope[modulePart], '__class__')
                    and global_scope[modulePart].__class__.__name__ == 'ModuleProxy'):
                    if pathname in repr(global_scope[modulePart]):
                        global_scope[modulePart] = mod

        return mod

    class ModuleProxy(object):
        __slots__ = []
        # we don't add any docs for the module in case the
        # user tries accessing '__doc__'
        def __hasattr__(self, key):
            mod = _loadModule()
            return hasattr(mod, key)

        def __getattr__(self, key):
            mod = _loadModule()
            try:
                return getattr(mod, key)
            except AttributeError:
                # A nicer error to compensate for the extra stack frame the
                # lazy importer adds.
                raise AttributeError("Module %r has no attribute %r" % (name,
                    key))

        def __setattr__(self, key, value):
            mod = _loadModule()
            return setattr(mod, key, value)

        def __repr__(self):
            return "<moduleProxy '%s' from '%s'>" % (name, pathname)

    return ModuleProxy()
List the n most common elements and their counts from the most
dataset/ETHPy150Open sassoftware/conary/conary/lib/importer.py/makeImportedModule--crossover with--dataset/ETHPy150Open dbcli/pgcli/pgcli/packages/counter.py/Counter.most_common