Spaces:
Runtime error
Runtime error
| """Functions for loading dynamic libraries. | |
| These extend and correct ctypes functions. | |
| """ | |
| import os | |
| import re | |
| import sys | |
| import ctypes | |
| import ctypes.util | |
| import pyglet | |
| _debug_lib = pyglet.options['debug_lib'] | |
| _debug_trace = pyglet.options['debug_trace'] | |
| _is_pyglet_doc_run = getattr(sys, "is_pyglet_doc_run", False) | |
| if pyglet.options['search_local_libs']: | |
| script_path = pyglet.resource.get_script_home() | |
| cwd = os.getcwd() | |
| _local_lib_paths = [script_path, os.path.join(script_path, 'lib'), os.path.join(cwd, 'lib')] | |
| if pyglet.compat_platform == 'win32': | |
| os.environ["PATH"] += os.pathsep + os.pathsep.join(_local_lib_paths) | |
| else: | |
| _local_lib_paths = None | |
| class _TraceFunction: | |
| def __init__(self, func): | |
| self.__dict__['_func'] = func | |
| def __str__(self): | |
| return self._func.__name__ | |
| def __call__(self, *args, **kwargs): | |
| return self._func(*args, **kwargs) | |
| def __getattr__(self, name): | |
| return getattr(self._func, name) | |
| def __setattr__(self, name, value): | |
| setattr(self._func, name, value) | |
| class _TraceLibrary: | |
| def __init__(self, library): | |
| self._library = library | |
| print(library) | |
| def __getattr__(self, name): | |
| func = getattr(self._library, name) | |
| f = _TraceFunction(func) | |
| return f | |
| if _is_pyglet_doc_run: | |
| class LibraryMock: | |
| """Mock library used when generating documentation.""" | |
| def __getattr__(self, name): | |
| return LibraryMock() | |
| def __setattr__(self, name, value): | |
| pass | |
| def __call__(self, *args, **kwargs): | |
| return LibraryMock() | |
| def __rshift__(self, other): | |
| return 0 | |
| class LibraryLoader: | |
| platform = pyglet.compat_platform | |
| # this is only for library loading, don't include it in pyglet.platform | |
| if platform == 'cygwin': | |
| platform = 'win32' | |
| def load_library(self, *names, **kwargs): | |
| """Find and load a library. | |
| More than one name can be specified, they will be tried in order. | |
| Platform-specific library names (given as kwargs) are tried first. | |
| Raises ImportError if library is not found. | |
| """ | |
| if _is_pyglet_doc_run: | |
| return LibraryMock() | |
| if 'framework' in kwargs and self.platform == 'darwin': | |
| return self.load_framework(kwargs['framework']) | |
| if not names: | |
| raise ImportError("No library name specified") | |
| platform_names = kwargs.get(self.platform, []) | |
| if isinstance(platform_names, str): | |
| platform_names = [platform_names] | |
| elif type(platform_names) is tuple: | |
| platform_names = list(platform_names) | |
| if self.platform.startswith('linux'): | |
| for name in names: | |
| libname = self.find_library(name) | |
| platform_names.append(libname or f'lib{name}.so') | |
| platform_names.extend(names) | |
| for name in platform_names: | |
| try: | |
| lib = ctypes.cdll.LoadLibrary(name) | |
| if _debug_lib: | |
| print(name, self.find_library(name)) | |
| if _debug_trace: | |
| lib = _TraceLibrary(lib) | |
| return lib | |
| except OSError as o: | |
| path = self.find_library(name) | |
| if path: | |
| try: | |
| lib = ctypes.cdll.LoadLibrary(path) | |
| if _debug_lib: | |
| print(path) | |
| if _debug_trace: | |
| lib = _TraceLibrary(lib) | |
| return lib | |
| except OSError: | |
| pass | |
| elif self.platform == "win32" and o.winerror != 126: | |
| if _debug_lib: | |
| print(f"Unexpected error loading library {name}: {str(o)}") | |
| raise ImportError(f'Library "{names[0]}" not found.') | |
| def find_library(self, name): | |
| return ctypes.util.find_library(name) | |
| def load_framework(name): | |
| raise RuntimeError("Can't load framework on this platform.") | |
| class MachOLibraryLoader(LibraryLoader): | |
| def __init__(self): | |
| if 'LD_LIBRARY_PATH' in os.environ: | |
| self.ld_library_path = os.environ['LD_LIBRARY_PATH'].split(':') | |
| else: | |
| self.ld_library_path = [] | |
| if _local_lib_paths: | |
| # search first for local libs | |
| self.ld_library_path = _local_lib_paths + self.ld_library_path | |
| os.environ['LD_LIBRARY_PATH'] = ':'.join(self.ld_library_path) | |
| if 'DYLD_LIBRARY_PATH' in os.environ: | |
| self.dyld_library_path = os.environ['DYLD_LIBRARY_PATH'].split(':') | |
| else: | |
| self.dyld_library_path = [] | |
| if 'DYLD_FALLBACK_LIBRARY_PATH' in os.environ: | |
| self.dyld_fallback_library_path = os.environ['DYLD_FALLBACK_LIBRARY_PATH'].split(':') | |
| else: | |
| self.dyld_fallback_library_path = [os.path.expanduser('~/lib'), '/usr/local/lib', '/usr/lib'] | |
| def find_library(self, path): | |
| """Implements the dylib search as specified in Apple documentation: | |
| http://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryUsageGuidelines.html | |
| Before commencing the standard search, the method first checks | |
| the bundle's ``Frameworks`` directory if the application is running | |
| within a bundle (OS X .app). | |
| """ | |
| libname = os.path.basename(path) | |
| search_path = [] | |
| if '.dylib' not in libname: | |
| libname = 'lib' + libname + '.dylib' | |
| # py2app support | |
| if getattr(sys, 'frozen', None) == 'macosx_app' and 'RESOURCEPATH' in os.environ: | |
| search_path.append(os.path.join(os.environ['RESOURCEPATH'], | |
| '..', | |
| 'Frameworks', | |
| libname)) | |
| # conda support | |
| if os.environ.get('CONDA_PREFIX', False): | |
| search_path.append(os.path.join(os.environ['CONDA_PREFIX'], 'lib', libname)) | |
| # pyinstaller.py sets sys.frozen to True, and puts dylibs in | |
| # Contents/macOS, which path pyinstaller puts in sys._MEIPASS | |
| if getattr(sys, 'frozen', False) and getattr(sys, '_MEIPASS', None): | |
| meipass = getattr(sys, '_MEIPASS') | |
| search_path.append(os.path.join(meipass, libname)) | |
| # conda support | |
| if os.environ.get('CONDA_PREFIX', False): | |
| search_path.append(os.path.join(os.environ['CONDA_PREFIX'], 'lib', libname)) | |
| if '/' in path: | |
| search_path.extend([os.path.join(p, libname) for p in self.dyld_library_path]) | |
| search_path.append(path) | |
| search_path.extend([os.path.join(p, libname) for p in self.dyld_fallback_library_path]) | |
| else: | |
| search_path.extend([os.path.join(p, libname) for p in self.ld_library_path]) | |
| search_path.extend([os.path.join(p, libname) for p in self.dyld_library_path]) | |
| search_path.append(path) | |
| search_path.extend([os.path.join(p, libname) for p in self.dyld_fallback_library_path]) | |
| for path in search_path: | |
| if os.path.exists(path): | |
| return path | |
| return None | |
| def load_framework(name): | |
| path = ctypes.util.find_library(name) | |
| # Hack for compatibility with macOS > 11.0 | |
| if path is None: | |
| frameworks = { | |
| 'AGL': '/System/Library/Frameworks/AGL.framework/AGL', | |
| 'IOKit': '/System/Library/Frameworks/IOKit.framework/IOKit', | |
| 'OpenAL': '/System/Library/Frameworks/OpenAL.framework/OpenAL', | |
| 'OpenGL': '/System/Library/Frameworks/OpenGL.framework/OpenGL' | |
| } | |
| path = frameworks.get(name) | |
| if path: | |
| lib = ctypes.cdll.LoadLibrary(path) | |
| if _debug_lib: | |
| print(path) | |
| if _debug_trace: | |
| lib = _TraceLibrary(lib) | |
| return lib | |
| raise ImportError(f"Can't find framework {name}.") | |
| class LinuxLibraryLoader(LibraryLoader): | |
| _ld_so_cache = None | |
| _local_libs_cache = None | |
| def _find_libs(directories): | |
| cache = {} | |
| lib_re = re.compile(r'lib(.*)\.so(?:$|\.)') | |
| for directory in directories: | |
| try: | |
| for file in os.listdir(directory): | |
| match = lib_re.match(file) | |
| if match: | |
| # Index by filename | |
| path = os.path.join(directory, file) | |
| if file not in cache: | |
| cache[file] = path | |
| # Index by library name | |
| library = match.group(1) | |
| if library not in cache: | |
| cache[library] = path | |
| except OSError: | |
| pass | |
| return cache | |
| def _create_ld_so_cache(self): | |
| # Recreate search path followed by ld.so. This is going to be | |
| # slow to build, and incorrect (ld.so uses ld.so.cache, which may | |
| # not be up-to-date). Used only as fallback for distros without | |
| # /sbin/ldconfig. | |
| # | |
| # We assume the DT_RPATH and DT_RUNPATH binary sections are omitted. | |
| directories = [] | |
| try: | |
| directories.extend(os.environ['LD_LIBRARY_PATH'].split(':')) | |
| except KeyError: | |
| pass | |
| try: | |
| with open('/etc/ld.so.conf') as fid: | |
| directories.extend([directory.strip() for directory in fid]) | |
| except IOError: | |
| pass | |
| directories.extend(['/lib', '/usr/lib']) | |
| self._ld_so_cache = self._find_libs(directories) | |
| def find_library(self, path): | |
| # search first for local libs | |
| if _local_lib_paths: | |
| if not self._local_libs_cache: | |
| self._local_libs_cache = self._find_libs(_local_lib_paths) | |
| if path in self._local_libs_cache: | |
| return self._local_libs_cache[path] | |
| # ctypes tries ldconfig, gcc and objdump. If none of these are | |
| # present, we implement the ld-linux.so search path as described in | |
| # the man page. | |
| result = ctypes.util.find_library(path) | |
| if result: | |
| return result | |
| if self._ld_so_cache is None: | |
| self._create_ld_so_cache() | |
| return self._ld_so_cache.get(path) | |
| if pyglet.compat_platform == 'darwin': | |
| loader = MachOLibraryLoader() | |
| elif pyglet.compat_platform.startswith('linux'): | |
| loader = LinuxLibraryLoader() | |
| else: | |
| loader = LibraryLoader() | |
| load_library = loader.load_library | |