Loads the libdmtx shared library.

    Populates the globals LIBDMTX and EXTERNAL_DEPENDENCIES.
195339
def load_libdmtx():
    
    global LIBDMTX
    global EXTERNAL_DEPENDENCIES
    if not LIBDMTX:
        LIBDMTX = dmtx_library.load()
        EXTERNAL_DEPENDENCIES = [LIBDMTX]

    return LIBDMTX
748050
def _load_library(library_names, library_file_extensions,
                  library_search_paths, version_check_callback):
    
    candidates = _find_library_candidates(library_names,
                                          library_file_extensions,
                                          library_search_paths)
    library_versions = []
    for filename in candidates:
        version = version_check_callback(filename)
        if version is not None and version >= (3, 0, 0):
            library_versions.append((version, filename))

    if not library_versions:
        return None
    library_versions.sort()
    return ctypes.CDLL(library_versions[-1][1])
1292034
private static Sc68Binding loadLibrary()
    {
        try
        {
            Verbose.info("Load library: ", LIBRARY_NAME);
            final Sc68Binding binding = Native.loadLibrary(LIBRARY_NAME, Sc68Binding.class);
            Verbose.info("Library ", LIBRARY_NAME, " loaded");
            return binding;
        }
        catch (final LinkageError exception)
        {
            throw new LionEngineException(exception, ERROR_LOAD_LIBRARY + LIBRARY_NAME);
        }
    }
945060
def load_module(module):
    
    try:
        m = importlib.import_module(module)
        return m
    except ModuleNotFoundError:  # pragma: no cover
        raise TImportError("Module `%s` is not installed. It is required for "
                           "running this function." % module)
135993
def dlopen(ffi, *names):
    """"""
    for name in names:
        for lib_name in (name, 'lib' + name):
            try:
                path = ctypes.util.find_library(lib_name)
                lib = ffi.dlopen(path or lib_name)
                if lib:
                    return lib
            except OSError:
                pass
    raise OSError("dlopen() failed to load a library: %s" % ' / '.join(names))
813006
def _load_all(self):
        '''
        
        '''
        with self._lock:
            for name in self.file_mapping:
                if name in self.loaded_files or name in self.missing_modules:
                    continue
                self._load_module(name)

            self.loaded = True
1029723
def load_all_resources():
    
    pkgname = resources.__name__
    for importer, mod_name, _ in pkgutil.iter_modules(resources.__path__):
        full_mod_name = '%s.%s' % (pkgname, mod_name)
        if full_mod_name not in sys.modules:
            module = importer.find_module(mod_name
                        ).load_module(full_mod_name)
            log.debug("Loaded resource from: %s", module)
509392
def load(cls, partname, content_type, blob, package):
        
        return cls(partname, content_type, blob)
253856
def add_external_library(library):
    

    for command in ['build', 'build_ext', 'install']:
        add_command_option(command, str('use-system-' + library),
                           'Use the system {0} library'.format(library),
                           is_bool=True)
1299684
def _load_greedy(self, module_name, dependencies, recursive):
        """"""
        found = module_name in self.modules
        allmodules = list(self._pathfiles.keys())
        i = 0

        while not found and i < len(allmodules):
            current = allmodules[i]
            if not current in self._modulefiles:
                #We haven't tried to parse this file yet
                self.parse(self._pathfiles[current], dependencies and recursive)                
                found = module_name in self.modules
            i += 1
1368764
def load(self):
        
        publish = self._get_publish()
        self.architectures = publish['Architectures']
        for source in publish['Sources']:
            component = source['Component']
            snapshot = source['Name']
            self.publish_snapshots.append({
                'Component': component,
                'Name': snapshot
            })

            snapshot_remote = self._find_snapshot(snapshot)
            for source in self._get_source_snapshots(snapshot_remote, fallback_self=True):
                self.add(source, component)
74863
def load_ctypes_library(name):
    

    try:
        return cdll.LoadLibrary(name)
    except OSError:
        name = find_library(name)
        if name is None:
            raise
        return cdll.LoadLibrary(name)
301784
def load_library(self,libname):
        """"""
        paths = self.getpaths(libname)

        for path in paths:
            if os.path.exists(path):
                return self.load(path)

        raise ImportError("%s not found." % libname)
1371706
def _loadSources(self):
        
        self.confstems = {}
        self.sourceDict = newtrigdict.Trigdict()
        for fName in self.authorityFiles:
            self._loadOneSource(fName)
        # We want to allow naked bibstems in references, too
        for stem in self.sourceDict.values():
            cleanStem = stem.replace(".", "").upper()
            self._addPub(stem, cleanStem)
697239
def cxx(source, libraries=[]):
    
    """
    path = _cc_build_shared_lib(source, '.cc', libraries)
    return ctypes.cdll.LoadLibrary(path)
488607
def load_tag_library(libname):
    
    from django.template.backends.django import get_installed_libraries
    from django.template.library import InvalidTemplateLibrary
    try:
        lib = get_installed_libraries()[libname]
        lib = importlib.import_module(lib).register
        return lib
    except (InvalidTemplateLibrary, KeyError):
        return None
68316
private Throwable loadLib(String _lib) {
        try {
            System.load(_lib);
            return null;
        } catch (Throwable _ex) {
            return _ex;
        }
    }