def test_libm(self): system = platform.system() if system == "Linux": libm = find_library("m") elif system == "Darwin": libm = find_library("libm") llvm.load_library_permanently(libm)
def find_boost(): """Find correct boost-python library information """ if system == 'Linux': # use version suffix if present boost_lib = 'boost_python-py{v[0]}{v[1]}'.format(v=sys.version_info) if sys.version_info.major == 3: if find_library('boost_python-py36'): boost_lib = 'boost_python-py36' elif find_library('boost_python-py35'): boost_lib = 'boost_python-py35' elif find_library('boost_python-py34'): boost_lib = 'boost_python-py34' if not find_library(boost_lib): boost_lib = "boost_python" elif system == 'Darwin': boost_lib = 'boost_python-mt' if sys.version_info[0] == 2 else 'boost_python3-mt' elif system == 'Cygwin': boost_lib = 'boost_python-mt' if sys.version_info[0] == 2 else 'boost_python3-mt' else: raise Exception('Building on this system is not currently supported') if not find_library(boost_lib): raise Exception('Could not find boost python library') return boost_lib
def find_boost(): """Find correct boost-python library information """ # find_library() has a tricky platform-dependent search behaviour # it is not easy to instruct it to do search in a particular location on Linux at least # skip find_library checks if python comes from conda # rely on conda to set up libboost_python.so link to what has been actually installed skip_find_library = ('conda' in sys.version) if system == 'Linux': # use version suffix if present boost_lib = 'boost_python-py{v[0]}{v[1]}'.format(v=sys.version_info) if sys.version_info.major == 3: for candidate in ['-py36', '-py35', '-py34', '3']: boost_lib = 'boost_python{}'.format(candidate) if find_library(boost_lib): break if not find_library(boost_lib) or skip_find_library: boost_lib = "boost_python" elif system == 'Darwin': # "brew" installations of PythonBoost put lib /usr/local/lib/libboost_python27-mt resp. libboost_python36-mt for candidate in ['{v[0]}{v[1]}'.format(v=sys.version_info), '{}-mt'.format(sys.version_info.major)]: boost_lib = 'boost_python{}'.format(candidate) if find_library(boost_lib): break if sys.version_info.major == 2: boost_lib = 'boost_python-mt' elif system == 'Cygwin': boost_lib = 'boost_python-mt' if sys.version_info[0] == 2 else 'boost_python3-mt' else: raise Exception('Building on this system is not currently supported') if not find_library(boost_lib) and not skip_find_library: raise Exception('Could not find boost python library') return boost_lib
def load_cprimeslib(): lib_path = find_library("cprimes") or find_library("libcprimes") lib = None # It's not where it should be. Maybe it's in the working directory? # Let's just try a bunch of names and hope for the best. if lib_path is None: names = [ "./libcprimes.so", # Linux "./libcprimes.dylib", # OS X "./libcprimes.dll", "./cprimes.dll" # MinGW and MSVC windows, respectively ] for name in names: # CDLL raises an exception when it cannot find the file # If it fails, move on to the next maybe name. # If not, we're done! try: lib = CDLL(name) break except: pass if lib is None: print("Error finding cprimes library.\nThe system couldn't find it, and it's not in the working directory.") sys.exit(1) # Python found a file with the right name, but things could still go wrong. else: try: lib = CDLL(lib_path) except OSError as e: print("Error finding cprimes:\n\t{}".format(e)) sys.exit(1) assert(lib is not None) return lib
def __init__(self): """ Find OpenMP library and try to load if using ctype interface. """ # find_library() does not search automatically LD_LIBRARY_PATH paths = os.environ.get('LD_LIBRARY_PATH', '').split(':') for gomp in ('libgomp.so', 'libgomp.dylib'): cmd = [cxx, '-print-file-name=' + gomp] # the subprocess can fail in various ways # in that case just give up that path try: path = os.path.dirname(check_output(cmd).strip()) if path: paths.append(path) except OSError: pass # Try to load find libgomp shared library using loader search dirs libgomp_path = find_library("gomp") # Try to use custom paths if lookup failed for path in paths: if libgomp_path: break path = path.strip() if os.path.isdir(path): libgomp_path = find_library(os.path.join(path, "libgomp")) if not libgomp_path: raise ImportError("I can't find a shared library for libgomp," " you may need to install it or adjust the " "LD_LIBRARY_PATH environment variable.") else: # Load the library (shouldn't fail with an absolute path right?) self.libomp = ctypes.CDLL(libgomp_path)
def __init__(self): if _system == 'Darwin': self.libiconv = CDLL(find_library('iconv'), RTLD_GLOBAL) super(LibFUSE, self).__init__(find_library('fuse')) self.fuse_mount.argtypes = (c_char_p, POINTER(fuse_args)) self.fuse_mount.restype = c_void_p self.fuse_lowlevel_new.argtypes = (POINTER(fuse_args), POINTER(fuse_lowlevel_ops), c_size_t, c_void_p) self.fuse_lowlevel_new.restype = c_void_p self.fuse_set_signal_handlers.argtypes = (c_void_p,) self.fuse_session_add_chan.argtypes = (c_void_p, c_void_p) self.fuse_session_loop.argtypes = (c_void_p,) self.fuse_remove_signal_handlers.argtypes = (c_void_p,) self.fuse_session_remove_chan.argtypes = (c_void_p,) self.fuse_session_destroy.argtypes = (c_void_p,) self.fuse_unmount.argtypes = (c_char_p, c_void_p) self.fuse_req_ctx.restype = POINTER(fuse_ctx) self.fuse_req_ctx.argtypes = (fuse_req_t,) self.fuse_reply_err.argtypes = (fuse_req_t, c_int) self.fuse_reply_attr.argtypes = (fuse_req_t, c_void_p, c_double) self.fuse_reply_entry.argtypes = (fuse_req_t, c_void_p) self.fuse_reply_open.argtypes = (fuse_req_t, c_void_p) self.fuse_reply_buf.argtypes = (fuse_req_t, c_char_p, c_size_t) self.fuse_reply_write.argtypes = (fuse_req_t, c_size_t) self.fuse_add_direntry.argtypes = (c_void_p, c_char_p, c_size_t, c_char_p, c_stat_p, c_off_t)
def __init__(self, display=None): ''' GNU/Linux initialisations. ''' if not display: try: display = environ['DISPLAY'] except KeyError: raise ScreenshotError( '$DISPLAY not set. Stopping to prevent segfault.') if not isinstance(display, bytes): display = bytes(display, 'utf-8') x11 = find_library('X11') if not x11: raise ScreenshotError('No X11 library found.') self.xlib = cdll.LoadLibrary(x11) xrandr = find_library('Xrandr') if not xrandr: raise ScreenshotError('No Xrandr extension found.') self.xrandr = cdll.LoadLibrary(xrandr) self._set_argtypes() self._set_restypes() self.display = self.xlib.XOpenDisplay(display) try: self.display.contents except ValueError: raise ScreenshotError('Cannot open display "{0}".'.format( str(display.decode('utf-8')))) self.root = self.xlib.XDefaultRootWindow( self.display, self.xlib.XDefaultScreen(self.display))
def _find_mv_path(cls): if platform.system() == "Windows": mv_lib_path = find_library("Multiverso") if mv_lib_path is None: print "* Fail to load Multiverso.dll from the windows $PATH."\ "Because Multiverso.dll can not be found in the $PATH "\ "directories. Go on loading Multiverso from the package." else: return mv_lib_path mv_lib_path = os.path.join(PACKAGE_PATH, "Multiverso.dll") if not os.path.exists(mv_lib_path): print "* Fail to load Multiverso.dll from the package. Because"\ " the file " + mv_lib_path + " can not be found." else: return mv_lib_path else: mv_lib_path = find_library("multiverso") if mv_lib_path is None: print "* Fail to load libmultiverso.so from the system"\ "libraries. Because libmultiverso.so can't be found in"\ "library paths. Go on loading Multiverso from the package." else: return mv_lib_path mv_lib_path = os.path.join(PACKAGE_PATH, "libmultiverso.so") if not os.path.exists(mv_lib_path): print "* Fail to load libmultiverso.so from the package. Because"\ " the file " + mv_lib_path + " can not be found." else: return mv_lib_path return None
def load_librtlsdr(): if sys.platform == "linux" and 'LD_LIBRARY_PATH' in os.environ.keys(): ld_library_paths = [local_path for local_path in os.environ['LD_LIBRARY_PATH'].split(':') if local_path.strip()] driver_files = [local_path + '/librtlsdr.so' for local_path in ld_library_paths] else: driver_files = [] driver_files += ['librtlsdr.so', 'rtlsdr/librtlsdr.so'] driver_files += ['rtlsdr.dll', 'librtlsdr.so'] driver_files += ['..//rtlsdr.dll', '..//librtlsdr.so'] driver_files += ['rtlsdr//rtlsdr.dll', 'rtlsdr//librtlsdr.so'] driver_files += [lambda : find_library('rtlsdr'), lambda : find_library('librtlsdr')] dll = None for driver in driver_files: if callable(driver): driver = driver() try: dll = CDLL(driver) break except: pass else: raise ImportError('Error loading librtlsdr. Make sure librtlsdr '\ '(and all of its dependencies) are in your path') return dll
def get_openmp_flag(): """ Find OpenMP library and try to load if using ctype interface. """ # find_library() does not search automatically LD_LIBRARY_PATH paths = os.environ.get('LD_LIBRARY_PATH', '').split(':') for gomp in ('libgomp.so', 'libgomp.dylib'): cmd = [cxx, '-print-file-name=' + gomp] # the subprocess can fail in various ways # in that case just give up that path try: path = os.path.dirname(check_output(cmd).strip()) if path: paths.append(path) except OSError: pass # Try to load find libgomp shared library using loader search dirs libgomp_path = find_library("gomp") # Try to use custom paths if lookup failed for path in paths: if libgomp_path: break path = path.strip() if os.path.isdir(path): libgomp_path = find_library(os.path.join(path, "libgomp")) if not libgomp_path: return '' else: return '-openmp'
def load_librtlsdr(): if platform.system() == 'Windows': # make sure that .DLL dependencies are accessible curr_path = os.path.dirname(__file__) os.environ['PATH'] += os.pathsep + curr_path driver_files = ['rtlsdr.dll', 'librtlsdr.so'] driver_files += ['..//rtlsdr.dll', '..//librtlsdr.so'] driver_files += ['rtlsdr//rtlsdr.dll', 'rtlsdr//librtlsdr.so'] driver_files += [find_library('rtlsdr'), find_library('librtlsdr')] dll = None for driver in driver_files: try: dll = CDLL(driver) break except: pass else: raise ImportError('Error loading librtlsdr. Make sure librtlsdr '\ '(and all of its dependencies) are in your path') return dll
def __init__(self, operations, mountpoint="/mnt", **kwargs): self.operations = operations if _system == 'Darwin': libiconv = CDLL(find_library("iconv"), RTLD_GLOBAL) libfuse = CDLL(find_library("fuse")) args = ['fuse'] if kwargs.pop('foreground', False): args.append('-f') if kwargs.pop('debug', False): args.append('-d') if kwargs: args.append('-o') args.append(','.join(key if val == True else '%s=%s' % (key, val) for key, val in kwargs.items())) args.append(mountpoint) argv = (c_char_p * len(args))(*args) fuse_ops = fuse_operations() for name, prototype in fuse_operations._fields_: method = getattr(self, name, None) if method: setattr(fuse_ops, name, prototype(method)) libfuse.fuse_main_real(len(args), argv, pointer(fuse_ops), sizeof(fuse_ops), None)
def _init(): """ Loads the shared library through ctypes and returns a library L{ctypes.CDLL} instance """ dll = None lib = find_library('magic') or find_library('magic1') if lib: dll = ctypes.cdll.LoadLibrary(lib) # Following shamelessly copied from python-magic if (not dll) or (not dll._name): import sys lib_map = { 'darwin' : ( '/opt/local/lib/libmagic.dylib', '/usr/local/lib/libmagic.dylib', '/usr/local/Cellar/libmagic/5.10/lib/libmagic.dylib', ), 'win32' : ( 'magic1.dll', ) } for libpath in lib_map.get(sys.platform, ()): try: dll = ctypes.cdll.LoadLibrary(libpath) except OSError: dll = None return dll
def _linux(): platform = PLATFORM_LINUX from ctypes.util import find_library from os import environ bcm_name = find_library('bcm_host') if bcm_name: platform = PLATFORM_PI bcm = _load_library(bcm_name) else: bcm = None if environ.get('ANDROID_APP_PATH'): platform = PLATFORM_ANDROID opengles = _load_library('/system/lib/libGLESv2.so') openegl = _load_library('/system/lib/libEGL.so') else: import os if os.path.isfile('/opt/vc/lib/libGLESv2.so'): # raspbian opengles = _load_library('/opt/vc/lib/libGLESv2.so') openegl = _load_library('/opt/vc/lib/libEGL.so') elif os.path.isfile('/usr/lib/libGLESv2.so'): # ubuntu MATE (but may catch others - monitor problems) opengles = _load_library('/usr/lib/libGLESv2.so') openegl = _load_library('/usr/lib/libEGL.so') else: opengles = _load_library(find_library('GLESv2')) # has to happen first openegl = _load_library(find_library('EGL')) # otherwise missing symbol on pi loading egl return platform, bcm, openegl, opengles # opengles now determined by platform
def __init__(self): ''' GNU/Linux initialisations ''' x11 = find_library('X11') if not x11: raise ScreenshotError('MSS: no X11 library found.') self.xlib = cdll.LoadLibrary(x11) xrandr = find_library('Xrandr') if not xrandr: raise ScreenshotError('MSS: no Xrandr library found.') self.xrandr = cdll.LoadLibrary(xrandr) self._set_argtypes() self._set_restypes() disp = None self.display = None try: if sys.version > '3': disp = bytes(environ['DISPLAY'], 'utf-8') else: disp = environ['DISPLAY'] except KeyError: err = 'MSS: $DISPLAY not set. Stopping to prevent segfault.' raise ScreenshotError(err) # At this point, if there is no running server, it could end on # a segmentation fault. And we cannot catch it. self.display = self.xlib.XOpenDisplay(disp) self.screen = self.xlib.XDefaultScreen(self.display) self.root = self.xlib.XDefaultRootWindow(self.display, self.screen)
def _find_library(name, version=0): """Find a library by base-name and major version """ windows_names = ["%s.dll" % name, "lib%s.dll" % name, "lib%s-%d.dll" % (name, version)] lib_file = None # This seems to be necessary in a bundle/dmg if sys.platform == "darwin": lib_name = '../Frameworks/lib%s.%d.dylib' % (name, version) if os.path.isfile(lib_name): lib_file = lib_name # force prefer current folder # for linux/UNIX-like and Windows if sys.platform in ["darwin", "cygwin"]: # these will already work fine with find_library pass elif sys.platform == "win32": for lib_name in windows_names: if os.path.isfile(lib_name): lib_file = lib_name break else: # that would be linux/UNIX-like # these need to prepend ./ lib_name = "./lib%s.so.%d" % (name, version) if os.path.isfile(lib_name): lib_file = lib_name # doesn't work on Windows # Darwin gives a full path when found system-wide # Linux and Cygwin give base filename when found # Darwin and Cygwin will find and prefer in current folder if lib_file is None: lib_file = find_library(name) # Windows needs complete filenames # and gives a full path when found system-wide # also searches in current folder, but system-wide preferred if lib_file is None and sys.platform == "win32": for lib_name in windows_names: if lib_file is None: lib_file = find_library(lib_name) if lib_file is None: # this won't help anymore, # but gives a nice platform dependent file in the error message if sys.platform == "win32": lib_file = "%s.dll" % name elif sys.platform == "darwin": lib_file = "lib%s.%d.dylib" % (name, version) elif sys.platform == "cygwin": lib_file = "cyg%s-%d.dll" % (name, version) else: lib_file = "lib%s.so.%d" % (name, version) return lib_file
def gather_pcap(self): pcap_location = ctutil.find_library('pcap') if(pcap_location): pcap = CDLL(ctutil.find_library('pcap')) pcap.pcap_lib_version.restype = c_char_p self.pcap_version = pcap.pcap_lib_version() else: self.pcap_version = "(none)"
def _load_crypto_libcrypto(): from ctypes import CDLL, POINTER, c_void_p, c_char_p, c_int, c_long, \ Structure, c_ulong, create_string_buffer, cast from ctypes.util import find_library if sys.platform.startswith('win'): libcrypto = find_library('libeay32') else: libcrypto = find_library('crypto') if libcrypto is None: raise IGNOBLEError('libcrypto not found') libcrypto = CDLL(libcrypto) AES_MAXNR = 14 c_char_pp = POINTER(c_char_p) c_int_p = POINTER(c_int) class AES_KEY(Structure): _fields_ = [('rd_key', c_long * (4 * (AES_MAXNR + 1))), ('rounds', c_int)] AES_KEY_p = POINTER(AES_KEY) def F(restype, name, argtypes): func = getattr(libcrypto, name) func.restype = restype func.argtypes = argtypes return func AES_cbc_encrypt = F(None, 'AES_cbc_encrypt', [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p, c_int]) AES_set_decrypt_key = F(c_int, 'AES_set_decrypt_key', [c_char_p, c_int, AES_KEY_p]) AES_cbc_encrypt = F(None, 'AES_cbc_encrypt', [c_char_p, c_char_p, c_ulong, AES_KEY_p, c_char_p, c_int]) class AES(object): def __init__(self, userkey): self._blocksize = len(userkey) if (self._blocksize != 16) and (self._blocksize != 24) and (self._blocksize != 32) : raise IGNOBLEError('AES improper key used') return key = self._key = AES_KEY() rv = AES_set_decrypt_key(userkey, len(userkey) * 8, key) if rv < 0: raise IGNOBLEError('Failed to initialize AES key') def decrypt(self, data): out = create_string_buffer(len(data)) iv = ("\x00" * self._blocksize) rv = AES_cbc_encrypt(data, out, len(data), self._key, iv, 0) if rv == 0: raise IGNOBLEError('AES decryption failed') return out.raw return AES
def _e_path_possibilities(): """Generator yielding possible locations of the enchant library.""" yield os.environ.get("PYENCHANT_LIBRARY_PATH") yield find_library("enchant") yield find_library("libenchant") yield find_library("libenchant-1") if sys.platform == 'darwin': # enchant lib installed by macports yield "/opt/local/lib/libenchant.dylib"
def _load_library_nix(self, version): library = find_library(self.library_name) if library is None and version is not None: # try to lookup with version. this is useful in linux, sometimes # there is'nt a libSDL.so but a libSDL-1.2.so library = find_library("%s-%s" % (self.library_name, version)) if not library: raise ImportError, 'Dynamic library "%s" was not found' % _platform_library_name(self.library_name) self._dll = getattr(cdll, library)
def __init__(self): if not c: raise PamRapiAuthError("ctypes Python package is not found;" " remote API PAM authentication is not available") self.libpam = c.CDLL(util.find_library("pam")) if not self.libpam: raise PamRapiAuthError("libpam C library is not found;" " remote API PAM authentication is not available") self.libc = c.CDLL(util.find_library("c")) if not self.libc: raise PamRapiAuthError("libc C library is not found;" " remote API PAM authentication is not available") self.pam_acct_mgmt = self.libpam.pam_acct_mgmt self.pam_acct_mgmt.argtypes = [PamHandleT, c.c_int] self.pam_acct_mgmt.restype = c.c_int self.pam_authenticate = self.libpam.pam_authenticate self.pam_authenticate.argtypes = [PamHandleT, c.c_int] self.pam_authenticate.restype = c.c_int self.pam_end = self.libpam.pam_end self.pam_end.argtypes = [PamHandleT, c.c_int] self.pam_end.restype = c.c_int self.pam_get_item = self.libpam.pam_get_item self.pam_get_item.argtypes = [PamHandleT, c.c_int, c.POINTER(c.c_void_p)] self.pam_get_item.restype = c.c_int self.pam_putenv = self.libpam.pam_putenv self.pam_putenv.argtypes = [PamHandleT, c.c_char_p] self.pam_putenv.restype = c.c_int self.pam_set_item = self.libpam.pam_set_item self.pam_set_item.argtypes = [PamHandleT, c.c_int, c.c_void_p] self.pam_set_item.restype = c.c_int self.pam_start = self.libpam.pam_start self.pam_start.argtypes = [ c.c_char_p, c.c_char_p, c.POINTER(PamConv), c.POINTER(PamHandleT), ] self.pam_start.restype = c.c_int self.calloc = self.libc.calloc self.calloc.argtypes = [c.c_uint, c.c_uint] self.calloc.restype = c.c_void_p self.free = self.libc.free self.free.argstypes = [c.c_void_p] self.free.restype = None self.strndup = self.libc.strndup self.strndup.argstypes = [c.c_char_p, c.c_uint] self.strndup.restype = c.c_char_p
def iter_lib(library_name): if not library_name: raise StopIteration if isinstance(library_name, str): yield library_name yield find_library(library_name.split('.')[0]) else: for name in library_name: yield name yield find_library(name.split('.')[0])
def _version(): ''' Return libavcodec version as a tuple: lib (libav or ffmpeg), major, minor and patch version ''' # find_library does not support LD_LIBRARY_PATH for python < 3.4 if 'AVPY_AVCODEC' in os.environ: fold, base = os.path.split(os.environ['AVPY_AVCODEC']) if 'AVPY_AVUTIL' in os.environ: libavutil = os.environ['AVPY_AVUTIL'] else: libavutil = os.path.join(fold, re.sub('avcodec', 'avutil', base)) if 'AVPY_AVRESAMPLE' in os.environ: libavresample = os.environ['AVPY_AVRESAMPLE'] else: libavresample = os.path.join(fold, re.sub('avcodec', 'avresample', base)) if 'AVPY_SWRESAMPLE' in os.environ: libswresample = os.environ['AVPY_SWRESAMPLE'] else: libswresample = os.path.join(fold, re.sub('avcodec', 'swresample', base)) libavcodec = os.environ['AVPY_AVCODEC'] else: libavutil = util.find_library('avutil') libswresample = util.find_library('swresample') libavresample = util.find_library('avresample') libavcodec = util.find_library('avcodec') # RTD tests (debug only) #libavutil = None #libavcodec = None #libswresample = None #libavresample = None CDLL(libavutil, RTLD_GLOBAL) # ffmpeg have both libswresample and libavresample # libav only have libavresample if libswresample and os.path.exists(libswresample): lib = 'ffmpeg' else: lib = 'libav' # libav11 if libavresample and os.path.exists(libavresample): CDLL(libavresample, RTLD_GLOBAL) version = CDLL(libavcodec, mode=RTLD_GLOBAL).avcodec_version() return lib, version >> 16 & 0xFF, version >> 8 & 0xFF, version & 0xFF
def _load_openSSL_linux_default(): # On Linux we use find_library() to find the OpenSSL libraries libcrypto_path = find_library('crypto') libssl_path = find_library('ssl') try: libcrypto = ctypes.CDLL(libcrypto_path, use_errno=True,use_last_error=True) libssl = ctypes.CDLL(libssl_path, use_errno=True, use_last_error=True) except OSError: raise ctSSLInitError('Could not load OpenSSL libraries.') return (libcrypto, libssl)
def setUpModule(): global libc_name if os.name == "nt": libc_name = find_library("c") elif sys.platform == "cygwin": libc_name = "cygwin1.dll" else: libc_name = find_library("c") if test.support.verbose: print("libc_name is", libc_name)
def _linux(): platform = PLATFORM_LINUX from ctypes.util import find_library bcm_name = find_library("bcm_host") if bcm_name: platform = PLATFORM_PI gles_name = find_library("GLESv2") egl_name = find_library("EGL") return platform, bcm_name, gles_name, egl_name
def _linux(): platform = PLATFORM_LINUX from ctypes.util import find_library bcm_name = find_library('bcm_host') if bcm_name: platform = PLATFORM_PI gles_name = find_library('GLESv2') egl_name = find_library('EGL') return platform, bcm_name, gles_name, egl_name
def __init__(self, filename, extradlls=[], timeout=10): self.timeout = timeout self.extradlls = [] for extradll in extradlls: extradll = find_library(extradll) self.extradlls.append(ctypes.windll.LoadLibrary(extradll)) dllfile = find_library(filename) self.dll = ctypes.windll.LoadLibrary(dllfile) self._poll_methods = [] self.registerPollMethods()
def test_load_library(self): # CRT is no longer directly loadable. See issue23606 for the # discussion about alternative approaches. #self.assertIsNotNone(libc_name) if test.support.verbose: print(find_library("kernel32")) print(find_library("user32")) if os.name == "nt": windll.kernel32.GetModuleHandleW windll["kernel32"].GetModuleHandleW windll.LoadLibrary("kernel32").GetModuleHandleW WinDLL("kernel32").GetModuleHandleW
def _loadLibrary(): import platform system = platform.system() if system == 'Linux': dll_loader = CDLL path = util.find_library('haildb') if path is None: path = util.find_library('innodb') else: raise NotImplementedError('System not supported: %r' % (system, )) if path is None: raise Exception('Can\'t locate haildb/innodb library') return dll_loader(path, **_func_type_kw)
# set/get process name (using ctypes & prctl) # set_proc_name('python rocks') # name = get_proc_name() import ctypes from ctypes.util import find_library libc = ctypes.CDLL(find_library('c')) PR_SET_NAME = 15 PR_GET_NAME = 16 def set_proc_name(name): libc.prctl(PR_SET_NAME, ctypes.c_char_p(name), 0, 0, 0) def get_proc_name(): name = ctypes.create_string_buffer(16) libc.prctl(PR_GET_NAME, name, 0, 0, 0) return name.value
#!/usr/bin/env python3 import asyncio import discord import random import re from discord.ext import commands from ctypes.util import find_library import cogs.utils.emby_helper as emby_helper from cogs.utils.format import * if not discord.opus.is_loaded(): try: discord.opus.load_opus('opus') except: discord.opus.load_opus(find_library('opus')) class VoiceEntry: def __init__(self, message, player=None, item=None): self.requester = message.author self.channel = message.channel self.player = player self.item = item def __str__(self): fmt = '*{0.title}* by {0.uploader} and requested by {1.display_name}' duration = self.player.duration if duration: fmt = fmt + ' [length: {0[0]}m {0[1]}s]'.format( divmod(duration, 60))
def contents(self): raise TypeError('This is not a ctypes pointer.') def __init__(self, **args): raise TypeError( 'This is not a ctypes pointer. It is not instanciable.') _class = type('LP_%d_%s' % (8, clsname), (_T, ), {}) ctypes._pointer_t_type_cache[clsname] = _class return _class _libraries = {} libpulse_library_name = find_library('pulse') if libpulse_library_name is None: raise Exception('No libpulse.so library found!') try: _libraries['libpulse.so'] = ctypes.cdll.LoadLibrary(libpulse_library_name) except OSError: raise Exception('Cannot load libpulse.so library!') uint32_t = ctypes.c_uint32 size_t = ctypes.c_uint64 class struct_pa_context(ctypes.Structure): pass
colorRef //= 256 green = colorRef % 256 colorRef //= 256 blue = colorRef return (red, green, blue) getPixel = _winGetPixel elif sys.platform == 'darwin': from rubicon.objc import ObjCClass, CGPoint from rubicon.objc.types import register_preferred_encoding ##################################################################### appkit = cdll.LoadLibrary(util.find_library('AppKit')) NSEvent = ObjCClass('NSEvent') NSEvent.declare_class_property('mouseLocation') # NSSystemDefined = ObjCClass('NSSystemDefined') ##################################################################### core_graphics = cdll.LoadLibrary(util.find_library('CoreGraphics')) CGDirectDisplayID = c_uint32 CGEventRef = c_void_p register_preferred_encoding(b'^{__CGEvent=}', CGEventRef) CGEventSourceRef = c_void_p
def _resolveCtypesImports(cbinaries): """Completes ctypes BINARY entries for modules with their full path. """ from ctypes.util import find_library if is_unix: envvar = "LD_LIBRARY_PATH" elif is_darwin: envvar = "DYLD_LIBRARY_PATH" else: envvar = "PATH" def _setPaths(): path = os.pathsep.join(PyInstaller.__pathex__) old = compat.getenv(envvar) if old is not None: path = os.pathsep.join((path, old)) compat.setenv(envvar, path) return old def _restorePaths(old): if old is None: compat.unsetenv(envvar) else: compat.setenv(envvar, old) ret = [] # Try to locate the shared library on disk. This is done by # executing ctypes.utile.find_library prepending ImportTracker's # local paths to library search paths, then replaces original values. old = _setPaths() for cbin in cbinaries: # Ignore annoying warnings like: # 'W: library kernel32.dll required via ctypes not found' # 'W: library coredll.dll required via ctypes not found' if cbin in ['coredll.dll', 'kernel32.dll']: continue ext = os.path.splitext(cbin)[1] # On Windows, only .dll files can be loaded. if os.name == "nt" and ext.lower() in [".so", ".dylib"]: continue cpath = find_library(os.path.splitext(cbin)[0]) if is_unix: # CAVEAT: find_library() is not the correct function. Ctype's # documentation says that it is meant to resolve only the filename # (as a *compiler* does) not the full path. Anyway, it works well # enough on Windows and Mac. On Linux, we need to implement # more code to find out the full path. if cpath is None: cpath = cbin # "man ld.so" says that we should first search LD_LIBRARY_PATH # and then the ldcache for d in compat.getenv(envvar, '').split(os.pathsep): if os.path.isfile(os.path.join(d, cpath)): cpath = os.path.join(d, cpath) break else: text = compat.exec_command("/sbin/ldconfig", "-p") for L in text.strip().splitlines(): if cpath in L: cpath = L.split("=>", 1)[1].strip() assert os.path.isfile(cpath) break else: cpath = None if cpath is None: logger.warn("library %s required via ctypes not found", cbin) else: ret.append((cbin, cpath, "BINARY")) _restorePaths(old) return ret
from ctypes import * import sys, unittest import os from ctypes.util import find_library from ctypes.test import is_resource_enabled libc_name = None if os.name == "nt": libc_name = find_library("c") elif os.name == "ce": libc_name = "coredll" elif sys.platform == "cygwin": libc_name = "cygwin1.dll" else: libc_name = find_library("c") if is_resource_enabled("printing"): print "libc_name is", libc_name class LoaderTest(unittest.TestCase): unknowndll = "xxrandomnamexx" if libc_name is not None: def test_load(self): CDLL(libc_name) CDLL(os.path.basename(libc_name)) self.assertRaises(OSError, CDLL, self.unknowndll)
def fc_list(): import ctypes from ctypes.util import find_library lib = find_library('fontconfig') if lib is None: return default_font_dirs() try: lib = ctypes.CDLL(lib) except Exception: return default_font_dirs() prototype = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p) try: get_font_dirs = prototype(('FcConfigGetFontDirs', lib)) except (AttributeError): return default_font_dirs() prototype = ctypes.CFUNCTYPE(ctypes.c_char_p, ctypes.c_void_p) try: next_dir = prototype(('FcStrListNext', lib)) except (AttributeError): return default_font_dirs() prototype = ctypes.CFUNCTYPE(None, ctypes.c_void_p) try: end = prototype(('FcStrListDone', lib)) except (AttributeError): return default_font_dirs() str_list = get_font_dirs(ctypes.c_void_p()) if not str_list: return default_font_dirs() ans = [] while True: d = next_dir(str_list) if not d: break if d: try: ans.append(d.decode(filesystem_encoding)) except ValueError: print(f'Ignoring undecodeable font path: {d}') continue end(str_list) if len(ans) < 3: return default_font_dirs() parents, visited = [], set() for f in ans: path = os.path.normpath(os.path.abspath(os.path.realpath(f))) if path == '/': continue head, tail = os.path.split(path) while head and tail: if head in visited: break head, tail = os.path.split(head) else: parents.append(path) visited.add(path) return parents
from ctypes.util import find_library from twisted.python.compat import _PY3, nativeString if _PY3: # Once #6070 is implemented, this can be replaced with the implementation # from that ticket: def chr(i): """ Python 3 implementation of Python 2 chr(), i.e. convert an integer to corresponding byte. """ return bytes([i]) libc = CDLL(find_library("c")) if sys.platform.startswith('freebsd') or sys.platform == 'darwin': _sockaddrCommon = [ ("sin_len", c_uint8), ("sin_family", c_uint8), ] else: _sockaddrCommon = [ ("sin_family", c_ushort), ] class in_addr(Structure): _fields_ = [ ("in_addr", c_ubyte * 4),
if dataCopy.get(key) == None: dataCopy[key] = -1 return dataCopy # Check if the scanned device is recognized def isRecDev(address): for devAdd in recDevAddr: if devAdd == address: return True return False ################################################################ if not os.geteuid() == 0: sys.exit("script only works as root") btlib = find_library("bluetooth") if not btlib: raise Exception( "Can't find required bluetooth libraries" " (need to install bluez)" ) bluez = CDLL(btlib, use_errno=True) dev_id = bluez.hci_get_route(None) sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI) sock.bind((dev_id,)) err = bluez.hci_le_set_scan_parameters(sock.fileno(), 0, 0x10, 0x10, 0, 0, 1000); if err < 0: raise Exception("Set scan parameters failed")
class c_utimbuf(Structure): _fields_ = [('actime', c_timespec), ('modtime', c_timespec)] class c_stat(Structure): pass # Platform dependent _system = system() _machine = machine() _libfuse_path = os.environ.get('FUSE_LIBRARY_PATH') if not _libfuse_path: if _system == 'Darwin': _libiconv = CDLL(find_library('iconv'), RTLD_GLOBAL) # libfuse dependency _libfuse_path = (find_library('fuse4x') or find_library('osxfuse') or find_library('fuse')) else: _libfuse_path = find_library('fuse') if not _libfuse_path: raise EnvironmentError('Unable to find libfuse') else: _libfuse = CDLL(_libfuse_path) if _system == 'Darwin' and hasattr(_libfuse, 'macfuse_version'): _system = 'Darwin-MacFuse' if _system in ('Darwin', 'Darwin-MacFuse', 'FreeBSD'):
# # Copyright Aliaksei Levin ([email protected]), Arseny Smirnov ([email protected]), # Pellegrino Prevete ([email protected]) 2014-2020 # # Distributed under the Boost Software License, Version 1.0. (See accompanying # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) # from ctypes.util import find_library from ctypes import * import json import sys # load shared library tdjson_path = find_library('tdjson') or 'tdjson.dll' if tdjson_path is None: print('can\'t find tdjson library') quit() tdjson = CDLL(tdjson_path) # load TDLib functions from shared library td_json_client_create = tdjson.td_json_client_create td_json_client_create.restype = c_void_p td_json_client_create.argtypes = [] td_json_client_receive = tdjson.td_json_client_receive td_json_client_receive.restype = c_char_p td_json_client_receive.argtypes = [c_void_p, c_double] td_json_client_send = tdjson.td_json_client_send td_json_client_send.restype = None td_json_client_send.argtypes = [c_void_p, c_char_p]
int TessBaseAPIRecognize(TessBaseAPI* handle, ETEXT_DESC* monitor); void TessBaseAPISetRectangle(TessBaseAPI* handle, int left, int top, int width, int height); char* TessBaseAPIGetUTF8Text(TessBaseAPI* handle); void TessDeleteText(char* text); BOOL TessBaseAPIDetectOrientationScript(TessBaseAPI* handle, char** best_script_name, int* best_orientation_deg, float* script_confidence, float* orientation_confidence); """) libtess = ffi.dlopen(PATH_TO_LIBTESS) from ctypes.util import find_library liblept = ffi.dlopen(find_library('lept')) tess_version=ffi.string(libtess.TessVersion()) lep_version=ffi.string(liblept.getLeptonicaVersion()) # dawg =libtess.GlobalDawgCache() api = libtess.TessBaseAPICreate() # lang='eng+chi_sim' # t0=current_milli_time() libtess.TessBaseAPIInit3(api, data_dir, lang) # print( "init tess in %d ms " % (current_milli_time()-t0) )
ISOTPSocket. """ import ctypes import sys from ctypes.util import find_library from scapy3k.packet import * from scapy3k.fields import * from scapy3k.supersocket import SuperSocket from scapy3k.sendrecv import sndrcv, sniff from scapy3k.arch.linux import get_last_packet_timestamp, SIOCGIFINDEX import socket if not sys.platform.startswith("win32"): libc = ctypes.cdll.LoadLibrary(find_library("c")) warning("Loading libc with ctypes") else: warning("libc is unavailable") libc = None """ ISOTP Packet """ class ISOTP(Packet): name = 'ISOTP' fields_desc = [ StrField('data', B"") ]
def __init__(self, handler, opts): _ISkypeAPIBase.__init__(self, opts) self.RegisterHandler(handler) # check options if opts: raise TypeError('Unexpected parameter(s): %s' % ', '.join(opts.keys())) # setup Xlib libpath = find_library('X11') if not libpath: raise ImportError('Could not find X11 library') self.x11 = cdll.LoadLibrary(libpath) # setup Xlib function prototypes self.x11.XCloseDisplay.argtypes = (DisplayP, ) self.x11.XCloseDisplay.restype = None self.x11.XCreateSimpleWindow.argtypes = (DisplayP, Window, c_int, c_int, c_uint, c_uint, c_uint, c_ulong, c_ulong) self.x11.XCreateSimpleWindow.restype = Window self.x11.XDefaultRootWindow.argtypes = (DisplayP, ) self.x11.XDefaultRootWindow.restype = Window self.x11.XDeleteProperty.argtypes = (DisplayP, Window, Atom) self.x11.XDeleteProperty.restype = None self.x11.XDestroyWindow.argtypes = (DisplayP, Window) self.x11.XDestroyWindow.restype = None self.x11.XPending.argtypes = (DisplayP, ) self.x11.XPending.restype = c_int self.x11.XGetAtomName.argtypes = (DisplayP, Atom) self.x11.XGetAtomName.restype = c_char_p self.x11.XGetErrorText.argtypes = (DisplayP, c_int, c_char_p, c_int) self.x11.XGetErrorText.restype = None self.x11.XGetWindowProperty.argtypes = (DisplayP, Window, Atom, c_long, c_long, Bool, Atom, AtomP, c_int_p, c_ulong_p, c_ulong_p, POINTER(POINTER(Window))) self.x11.XGetWindowProperty.restype = c_int self.x11.XInitThreads.argtypes = () self.x11.XInitThreads.restype = Status self.x11.XInternAtom.argtypes = (DisplayP, c_char_p, Bool) self.x11.XInternAtom.restype = Atom self.x11.XNextEvent.argtypes = (DisplayP, XEventP) self.x11.XNextEvent.restype = None self.x11.XOpenDisplay.argtypes = (c_char_p, ) self.x11.XOpenDisplay.restype = DisplayP self.x11.XSelectInput.argtypes = (DisplayP, Window, c_long) self.x11.XSelectInput.restype = None self.x11.XSendEvent.argtypes = (DisplayP, Window, Bool, c_long, XEventP) self.x11.XSendEvent.restype = Status self.x11.XSetErrorHandler.argtypes = (XErrorHandlerP, ) self.x11.XSetErrorHandler.restype = None self.x11.XLockDisplay.argtypes = (DisplayP, ) self.x11.XLockDisplay.restype = None self.x11.XUnlockDisplay.argtypes = (DisplayP, ) self.x11.XUnlockDisplay.restype = None # init Xlib self.x11.XInitThreads() self.error = None # callback has to be saved to keep reference to bound method self._error_handler_callback = XErrorHandlerP(self._error_handler) self.x11.XSetErrorHandler(self._error_handler_callback) self.disp = self.x11.XOpenDisplay(None) if not self.disp: raise ISkypeAPIError('Could not open XDisplay') self.win_root = self.x11.XDefaultRootWindow(self.disp) self.win_self = self.x11.XCreateSimpleWindow(self.disp, self.win_root, 100, 100, 100, 100, 1, 0, 0) self.x11.XSelectInput(self.disp, self.win_root, _PropertyChangeMask) self.win_skype = self.get_skype() ctrl = 'SKYPECONTROLAPI_MESSAGE' self.atom_msg = self.x11.XInternAtom(self.disp, ctrl, False) self.atom_msg_begin = self.x11.XInternAtom(self.disp, ctrl + '_BEGIN', False) self.loop_event = threading.Event() self.loop_timeout = 0.0001 self.loop_break = False
else: return ('127.0.0.1', 8333) def connect (addr): addr1 = parse_addr_arg (addr) G.out_conn_sem.acquire (1) addr0 = get_my_addr (addr1) Connection (addr0, addr1) def exception_notifier(): LOG.exc() # --- daemonize --- # this will be in shrapnel soon. from ctypes import cdll, util libc = cdll.LoadLibrary (util.find_library ('libc')) def daemonize (nochdir=1, noclose=0): libc.daemon (nochdir, noclose) # ----------------- import pwd def become (username): os.setuid (pwd.getpwnam(username).pw_uid) import coro.http import coro.backdoor import caesure.webadmin import zlib def main1 (args, G):
def _load_te_proteus_library(self, lib_dir_path=None): '''Loads the `TEProteus.dll`.''' if lib_dir_path is None: script_dir = os.path.realpath(__file__) script_dir = os.path.dirname(script_dir) lib_path = os.path.join(script_dir, 'TEProteus.dll') if os.path.exists(lib_path): lib_dir_path = script_dir if lib_dir_path is not None: libpath = os.path.join(lib_dir_path, 'TEProteus.dll') else: libpath = find_library('TEProteus.dll') if not libpath: sys32path = str('C:/Windows/System32/TEProteus.dll') if os.path.exists(sys32path): libpath = sys32path teplib = ct.cdll.LoadLibrary(libpath) if teplib is None: raise Exception('failed to load TEProteus.dll') self._libpath = libpath self._teplib = teplib self._tep_open_inst_admin = teplib.tep_open_inst_admin self._tep_open_inst_admin.restype = ct.c_int self._tep_open_inst_admin.argtypes = None self._tep_close_inst_admin = teplib.tep_close_inst_admin self._tep_close_inst_admin.restype = ct.c_int self._tep_close_inst_admin.argtypes = None self._tep_is_inst_admin_open = teplib.tep_is_inst_admin_open self._tep_is_inst_admin_open.restype = ct.c_int self._tep_is_inst_admin_open.argtypes = None self._tep_get_slot_ids = teplib.tep_get_slot_ids self._tep_get_slot_ids.restype = ct.c_uint32 self._tep_get_slot_ids.argtypes = [ ndpointer(ct.c_uint32, flags="C_CONTIGUOUS"), ct.c_uint32] self._tep_get_slot_info = teplib.tep_get_slot_info self._tep_get_slot_info.restype = ct.c_int64 self._tep_get_slot_info.argtypes = [ct.c_uint32, ] self._tep_get_slot_number = teplib.tep_get_slot_number self._tep_get_slot_number.restype = ct.c_uint16 self._tep_get_slot_number.argtypes = [ct.c_int64, ] self._tep_get_slot_chassis_index = teplib.tep_get_slot_chassis_index self._tep_get_slot_chassis_index.restype = ct.c_uint16 self._tep_get_slot_chassis_index.argtypes = [ct.c_int64, ] self._tep_get_slot_is_dummy = teplib.tep_get_slot_is_dummy self._tep_get_slot_is_dummy.restype = ct.c_int32 self._tep_get_slot_is_dummy.argtypes = [ct.c_int64, ] self._tep_get_slot_is_in_use = teplib.tep_get_slot_is_in_use self._tep_get_slot_is_in_use.restype = ct.c_int32 self._tep_get_slot_is_in_use.argtypes = [ct.c_int64, ] self._tep_get_slot_parent_instr_id = \ teplib.tep_get_slot_parent_instr_id self._tep_get_slot_parent_instr_id.restype = ct.c_uint16 self._tep_get_slot_parent_instr_id.argtypes = [ct.c_int64, ] self._tep_get_slot_fpga_version = teplib.tep_get_slot_fpga_version self._tep_get_slot_fpga_version.restype = ct.c_uint32 self._tep_get_slot_fpga_version.argtypes = [ct.c_int64, ] self._tep_get_slot_fpga_svn = teplib.tep_get_slot_fpga_svn self._tep_get_slot_fpga_svn.restype = ct.c_uint32 self._tep_get_slot_fpga_svn.argtypes = [ct.c_int64, ] self._tep_get_slot_fpga_date = teplib.tep_get_slot_fpga_date self._tep_get_slot_fpga_date.restype = ct.c_int32 self._tep_get_slot_fpga_date.argtypes = [ ct.c_int64, ct.c_char_p, ct.POINTER(ct.c_char), ct.c_uint32] self._tep_get_slot_idn_str = teplib.tep_get_slot_idn_str self._tep_get_slot_idn_str.restype = ct.c_int32 self._tep_get_slot_idn_str.argtypes = [ ct.c_int64, ct.c_char_p, ct.POINTER(ct.c_char), ct.c_uint32] self._tep_get_slot_fw_options = teplib.tep_get_slot_fw_options self._tep_get_slot_fw_options.restype = ct.c_uint32 self._tep_get_slot_fw_options.argtypes = [ct.c_int64, ] self._tep_get_slot_hw_options = teplib.tep_get_slot_hw_options self._tep_get_slot_hw_options.restype = ct.c_uint32 self._tep_get_slot_hw_options.argtypes = [ct.c_int64, ] self._tep_get_slot_installed_memory = \ teplib.tep_get_slot_installed_memory self._tep_get_slot_installed_memory.restype = ct.c_uint32 self._tep_get_slot_installed_memory.argtypes = [ct.c_int64, ] self._tep_open_instrument = teplib.tep_open_instrument self._tep_open_instrument.restype = ct.c_int64 self._tep_open_instrument.argtypes = [ct.c_uint32, ct.c_int] self._tep_open_multi_slots_instrument = \ teplib.tep_open_multi_slots_instrument self._tep_open_multi_slots_instrument.restype = ct.c_int64 self._tep_open_multi_slots_instrument.argtypes = [ ndpointer(ct.c_uint32, flags="C_CONTIGUOUS"), ct.c_uint32, ct.c_int] self._tep_close_instrument = teplib.tep_close_instrument self._tep_close_instrument.restype = ct.c_int self._tep_close_instrument.argtypes = [ct.c_int64, ] self._tep_close_all_instruments = teplib.tep_close_all_instruments self._tep_close_all_instruments.restype = ct.c_int self._tep_close_all_instruments.argtypes = None self._tep_get_instrument_id = teplib.tep_get_instrument_id self._tep_get_instrument_id.restype = ct.c_uint16 self._tep_get_instrument_id.argtypes = [ct.c_int64, ] self._tep_open_comm_intf = teplib.tep_open_comm_intf self._tep_open_comm_intf.restype = ct.c_int64 self._tep_open_comm_intf.argtypes = [ct.c_int64, ] self._tep_close_comm_intf = teplib.tep_close_comm_intf self._tep_close_comm_intf.restype = ct.c_int self._tep_close_comm_intf.argtypes = [ct.c_int64, ct.c_int64] self._tep_send_scpi = teplib.tep_send_scpi self._tep_send_scpi.restype = ct.c_int self._tep_send_scpi.argtypes = [ ct.c_int64, ct.c_char_p, ct.POINTER(ct.c_char), ct.c_uint32] self._tep_write_binary_data = teplib.tep_write_binary_data self._tep_write_binary_data.restype = ct.c_int self._tep_write_binary_data.argtypes = [ ct.c_int64, ct.c_char_p, ct.POINTER(ct.c_uint8), ct.c_uint64] self._tep_read_binary_data = teplib.tep_read_binary_data self._tep_read_binary_data.restype = ct.c_int self._tep_read_binary_data.argtypes = [ ct.c_int64, ct.c_char_p, ct.POINTER(ct.c_uint8), ct.c_uint64] self._tep_get_write_stream_intf = teplib.tep_get_write_stream_intf self._tep_get_write_stream_intf.restype = ct.c_int64 self._tep_get_write_stream_intf.argtypes = [ct.c_int64, ct.c_int] self._tep_get_stream_packet_size = teplib.tep_get_stream_packet_size self._tep_get_stream_packet_size.restype = ct.c_uint32 self._tep_get_stream_packet_size.argtypes = None self._tep_is_write_stream_active = teplib.tep_is_write_stream_active self._tep_is_write_stream_active.restype = ct.c_int self._tep_is_write_stream_active.argtypes = [ct.c_int64, ] self._tep_get_stream_empty_buff = teplib.tep_get_stream_empty_buff self._tep_get_stream_empty_buff.restype = ct.POINTER(ct.c_uint8) self._tep_get_stream_empty_buff.argtypes = [ct.c_int64, ] self._tep_put_stream_full_buff = teplib.tep_put_stream_full_buff self._tep_put_stream_full_buff.restype = ct.c_int self._tep_put_stream_full_buff.argtypes = [ ct.c_int64, ct.POINTER(ct.c_uint8), ct.c_int] self._tep_put_stream_empty_buff = teplib.tep_put_stream_empty_buff self._tep_put_stream_empty_buff.restype = ct.c_int self._tep_put_stream_empty_buff.argtypes = [ ct.c_int64, ct.POINTER(ct.c_uint8)] self._tep_push_stream_packet = teplib.tep_push_stream_packet self._tep_push_stream_packet.restype = ct.c_int self._tep_push_stream_packet.argtypes = [ ct.c_int64, ct.POINTER(ct.c_uint8), ct.c_int64, ct.c_int]
import sys import os.path import numpy import copy numpy.seterr(all="ignore") if platform.system( ) == "Linux": # Needed for platform.linux_distribution, which is not available on Windows and OSX # For Ubuntu: https://bugs.launchpad.net/ubuntu/+source/python-qt4/+bug/941826 if platform.linux_distribution()[0] in ( "Ubuntu", ): # TODO: Needs a "if X11_GFX == 'nvidia'" here. The workaround is only needed on Ubuntu+NVidia drivers. Other drivers are not affected, but fine with this fix. import ctypes from ctypes.util import find_library ctypes.CDLL(find_library('GL'), ctypes.RTLD_GLOBAL) try: from cura.CuraVersion import CuraVersion except ImportError: CuraVersion = "master" # [CodeStyle: Reflecting imported value] class CuraApplication(QtApplication): class ResourceTypes: QmlFiles = Resources.UserType + 1 Firmware = Resources.UserType + 2 Q_ENUMS(ResourceTypes) def __init__(self):
from ctypes.util import find_library from ctypes import ( c_void_p, c_int32, c_char_p, c_size_t, c_byte, c_uint32, c_ulong, c_long, c_bool, ) from ctypes import CDLL, POINTER, CFUNCTYPE security_path = find_library("Security") if not security_path: raise ImportError("The library Security could not be found") core_foundation_path = find_library("CoreFoundation") if not core_foundation_path: raise ImportError("The library CoreFoundation could not be found") version = platform.mac_ver()[0] version_info = tuple(map(int, version.split("."))) if version_info < (10, 8): raise OSError( "Only OS X 10.8 and newer are supported, not %s.%s" % (version_info[0], version_info[1])
NOTEOFF events to play notes. Instruments are defined in SoundFonts, generally files with the extension SF2. FluidSynth can either be used to play audio itself, or you can call a function that returns chunks of audio data and output the data to the soundcard yourself. FluidSynth works on all major platforms, so pyFluidSynth should also. """ import time import numpy from ctypes import * from ctypes.util import find_library # Dynamically link the FluidSynth library _fl = CDLL(find_library('fluidsynth')) # make function prototypes a bit easier to declare def cfunc(name, result, *args): """build and apply a ctypes prototype complete with parameter flags""" atypes = [] aflags = [] for arg in args: atypes.append(arg[1]) aflags.append((arg[2], arg[0]) + arg[3:]) return CFUNCTYPE(result, *atypes)((name, _fl), tuple(aflags)) # Bump this up when changing the interface for users api_version = '1.2'
('underline_position', FT_Short), ('underline_thickness', FT_Short), ('glyph', FT_GlyphSlot), ('size', FT_Size), ('charmap', FT_Charmap), ('driver', c_void_p), ('memory', c_void_p), ('stream', c_void_p), ('sizes_list_head', c_void_p), ('sizes_list_tail', c_void_p), ('autohint', FT_Generic), ('extensions', c_void_p), ('internal', c_void_p)] FT_Face = POINTER(FT_FaceRec) ############################################################################## # __init__.py __dll__ = None FT_Library_filename = util.find_library('freetype') if not FT_Library_filename and sys.platform.startswith('win'): fname_end = '_x64.dll' if _64_bit else '.dll' FT_Library_filename = load_data_file('freetype/freetype253' + fname_end) if not FT_Library_filename: raise ImportError('Freetype library not found') if not __dll__: __dll__ = CDLL(FT_Library_filename) FT_Init_FreeType = __dll__.FT_Init_FreeType FT_Done_FreeType = __dll__.FT_Done_FreeType FT_Library_Version = __dll__.FT_Library_Version __handle__ = None
from ipalib import x509 # FIXME: do not import from ipalib from ipaplatform.constants import constants from ipaplatform.paths import paths from ipaplatform.redhat.authconfig import RedHatAuthConfig from ipaplatform.base.tasks import BaseTaskNamespace _ffi = FFI() _ffi.cdef(""" int rpmvercmp (const char *a, const char *b); """) # use ctypes loader to get correct librpm.so library version according to # https://cffi.readthedocs.org/en/latest/overview.html#id8 _librpm = _ffi.dlopen(find_library("rpm")) log = log_mgr.get_logger(__name__) def selinux_enabled(): """ Check if SELinux is enabled. """ if os.path.exists(paths.SELINUXENABLED): try: ipautil.run([paths.SELINUXENABLED]) return True except ipautil.CalledProcessError: # selinuxenabled returns 1 if not enabled return False
def test_find(self): for name in ("c", "m"): lib = find_library(name) if lib: cdll.LoadLibrary(lib) CDLL(lib)
def create_keychain_accessor(): from ctypes import cdll, util, c_uint32, c_int, c_char_p, c_void_p, POINTER, pointer, byref, Structure, string_at lib_security = cdll.LoadLibrary(util.find_library('Security')) class SecKeychainAttributeInfo(Structure): _fields_ = [("count", c_uint32), ("tag", POINTER(c_uint32)), ("format", POINTER(c_uint32))] class SecKeychainAttribute(Structure): _fields_ = [("tag", c_uint32), ("length", c_uint32), ("data", c_void_p)] class SecKeychainAttributeList(Structure): _fields_ = [("count", c_uint32), ("attr", POINTER(SecKeychainAttribute))] PtrSecKeychainAttributeList = POINTER(SecKeychainAttributeList) def keychain_get_credentials(): username = settings.get('username') password = settings.get('password') if username and password: return (username, password) password_buflen = c_uint32() password_buf = c_void_p() item = c_void_p() error = lib_security.SecKeychainFindInternetPassword( None, # keychain, NULL = default c_uint32(len(SERVER)), # server name length c_char_p(SERVER), # server name c_uint32(0), # security domain - unused None, # security domain - unused c_uint32(0 if not username else len(username) ), # account name length None if not username else c_char_p(username), # account name c_uint32(0), # path name length - unused None, # path name c_uint32(0), # port, 0 = any c_int(0), # kSecProtocolTypeAny c_int(0), # kSecAuthenticationTypeAny None, # returned password length - unused None, # returned password data - unused byref(item)) # returned keychain item reference if not error: info = SecKeychainAttributeInfo( 1, # attribute count pointer(c_uint32(1633903476)), # kSecAccountItemAttr pointer(c_uint32(6))) # CSSM_DB_ATTRIBUTE_FORMAT_BLOB attrlist_ptr = PtrSecKeychainAttributeList() error = lib_security.SecKeychainItemCopyAttributesAndData( item, # keychain item reference byref(info), # list of attributes to retrieve None, # returned item class - unused byref(attrlist_ptr), # returned attribute data byref(password_buflen), # returned password length byref(password_buf)) # returned password data if not error: try: if attrlist_ptr.contents.count == 1: attr = attrlist_ptr.contents.attr.contents username = string_at(attr.data, attr.length) password = string_at(password_buf.value, password_buflen.value) finally: lib_security.SecKeychainItemFreeAttributesAndData( attrlist_ptr, password_buf) if not username or not password: raise MissingCredentialsException() else: return (username, password) return keychain_get_credentials
def __init__(self, value): self._as_parameter = int(value) @classmethod def from_param(cls, obj): return int(obj) APS_PY_WRAPPER_VERSION = 1.5 APS_ROOT = os.path.realpath( os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../')) # load the shared library # try with and without "lib" prefix libpath = find_library("aps") if libpath is None: libpath = find_library("libaps") # if we still can't find it, then look in python prefix (where conda stores binaries) if libpath is None: try: libaps = npct.load_library("libaps", libpath) #Finally... load it from this directory except OSError: libpath = os.path.join(APS_ROOT, 'build') libaps = npct.load_library("libaps", libpath) else: libaps = ctypes.CDLL(libpath) # set up argtypes and restype for functions with arguments that aren't ints or strings libaps.set_channel_scale.argtypes = [
__all__ = [ 'libsvm', 'svm_problem', 'svm_parameter', 'toPyModel', 'gen_svm_nodearray', 'print_null', 'svm_node', 'C_SVC', 'EPSILON_SVR', 'LINEAR', 'NU_SVC', 'NU_SVR', 'ONE_CLASS', 'POLY', 'PRECOMPUTED', 'PRINT_STRING_FUN', 'RBF', 'SIGMOID', 'c_double', 'svm_model' ] try: dirname = path.dirname(path.abspath(__file__)) if sys.platform == 'win32': libsvm = CDLL(path.join(dirname, r'..\windows\libsvm.dll')) else: libsvm = CDLL(path.join(dirname, '../libsvm.so.2')) except: # For unix the prefix 'lib' is not considered. if find_library('svm'): libsvm = CDLL(find_library('svm')) elif find_library('libsvm'): libsvm = CDLL(find_library('libsvm')) else: raise Exception('LIBSVM library not found.') C_SVC = 0 NU_SVC = 1 ONE_CLASS = 2 EPSILON_SVR = 3 NU_SVR = 4 LINEAR = 0 POLY = 1 RBF = 2
# constants adapted from C header file <pcp/pmapi.h> from pcp.pmapi import pmErr from cpmapi import PM_ERR_IPC # for interfacing with libpcp - the client-side C API from ctypes import CDLL, Structure, POINTER, cast, byref from ctypes import c_void_p, c_char_p, c_int, c_long from ctypes.util import find_library ############################################################################## # # dynamic library loads # LIBPCP_GUI = CDLL(find_library("pcp_gui")) LIBC = CDLL(find_library("c")) ############################################################################## # # definition of structures used by C library libpcp, derived from <pcp/pmafm.h> # class pmRecordHost(Structure): """state information between the recording session and the pmlogger """ _fields_ = [("f_config", c_void_p), ("fd_ipc", c_int), ("logfile", c_char_p), ("pid", c_int), ("status", c_int)] ##############################################################################
from cffi import FFI except (ImportError): raise FFIEngineError('Error importing cffi') __all__ = [ 'libcrypto', 'version', 'version_info', ] ffi = FFI() ffi.cdef("const char *SSLeay_version(int type);") libcrypto_path = find_library('crypto') if not libcrypto_path: raise LibraryNotFoundError('The library libcrypto could not be found') libcrypto = ffi.dlopen(libcrypto_path) register_ffi(libcrypto, ffi) version_string = ffi.string(libcrypto.SSLeay_version(0)).decode('utf-8') version_match = re.search('\\b(\\d\\.\\d\\.\\d[a-z]*)\\b', version_string) if not version_match: version_match = re.search('(?<=LibreSSL )(\\d\\.\\d(\\.\\d)?)\\b', version_string) if not version_match: raise LibraryNotFoundError('Error detecting the version of libcrypto') version = version_match.group(1) version_parts = re.sub('(\\d)([a-z]+)', '\\1.\\2', version).split('.')
import ctypes.util as cutil import logging import envi.memory as e_mem import envi.cli as e_cli import vtrace import vtrace.archs.i386 as v_i386 import vtrace.archs.amd64 as v_amd64 import vtrace.platforms.base as v_base import vtrace.platforms.posix as v_posix import vtrace.util as v_util logger = logging.getLogger(__name__) libc = ctypes.CDLL(cutil.find_library("c")) libkvm = ctypes.CDLL(cutil.find_library("kvm")) # kvm_getprocs cmds KERN_PROC_ALL = 0 # everything KERN_PROC_PID = 1 # by process id KERN_PROC_PGRP = 2 # by process group id KERN_PROC_SESSION = 3 # by session of pid KERN_PROC_TTY = 4 # by controlling tty KERN_PROC_UID = 5 # by effective uid KERN_PROC_RUID = 6 # by real uid KERN_PROC_ARGS = 7 # get/set arguments/proctitle KERN_PROC_PROC = 8 # only return procs KERN_PROC_SV_NAME = 9 # get syscall vector name KERN_PROC_RGID = 10 # by real group id KERN_PROC_GID = 11 # by effective group id
def _os_uptime(): """ Get the OS uptime. Because this is highly operating system dependent, several different strategies may have to be tried:""" try: # For Python 3.7 and later, most systems return time.clock_gettime(time.CLOCK_UPTIME) except AttributeError: pass try: # For Python 3.3 and later, most systems return time.clock_gettime(time.CLOCK_MONOTONIC) except AttributeError: pass try: # For Linux, Python 2 and 3: return float(open("/proc/uptime").read().split()[0]) except (IOError, KeyError, OSError): pass try: # For MacOS, Python 2: from Quartz.QuartzCore import CACurrentMediaTime return CACurrentMediaTime() except ImportError: pass try: # for FreeBSD, Python 2 import ctypes from ctypes.util import find_library libc = ctypes.CDLL(find_library('c')) size = ctypes.c_size_t() buf = ctypes.c_int() size.value = ctypes.sizeof(buf) libc.sysctlbyname("kern.boottime", ctypes.byref(buf), ctypes.byref(size), None, 0) os_uptime_secs = time.time() - float(buf.value) return os_uptime_secs except (ImportError, AttributeError, IOError, NameError): pass try: # For OpenBSD, Python 2. See issue #428. import subprocess from datetime import datetime cmd = ['sysctl', 'kern.boottime'] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) o, e = proc.communicate() # Check for errors if e: raise IOError time_t = o.decode('ascii').split() time_as_string = time_t[1] + " " + time_t[2] + " " + time_t[ 4][:4] + " " + time_t[3] os_time = datetime.strptime(time_as_string, "%b %d %Y %H:%M:%S") epoch_time = (os_time - datetime(1970, 1, 1)).total_seconds() os_uptime_secs = time.time() - epoch_time return os_uptime_secs except (IOError, IndexError, ValueError): pass # Nothing seems to be working. Return None return None
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys if sys.platform == "linux" or sys.platform == "linux2": # TODO remove this OpenGL fix when PyQt # doesn't require OpenGL to be loaded first. # NOTE This must be placed before any other imports! import ctypes from ctypes.util import find_library libGL = find_library("GL") ctypes.CDLL(libGL, ctypes.RTLD_GLOBAL) from PyQt5.QtCore import * from PyQt5.QtGui import * from PyQt5.QtQml import * from PyQt5.QtWidgets import * import qml_qrc def main(): app = QApplication(sys.argv) engine = QQmlApplicationEngine() engine.load(QUrl("qrc:/main.qml")) return app.exec_() if __name__ == "__main__": sys.exit(main())