Ejemplo n.º 1
0
def python(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    dll.InitializePython.restype = BOOL
    dll.InitializePython.argtypes = [HMODULE, PVOID, PDWORD]

    return dll
Ejemplo n.º 2
0
def load_module(name, verbose=True):
    if verbose:
        print('Loading module', name)
    try:
        if get_os_name() == 'osx':
            mode = ctypes.RTLD_LOCAL
        else:
            mode = ctypes.RTLD_GLOBAL
        if '.so' in name:
            ctypes.PyDLL(name, mode=mode)
        else:
            ctypes.PyDLL(os.path.join(get_repo_directory(), 'build',
                                      get_dll_name(name)),
                         mode=mode)
    except Exception as e:
        print(Fore.YELLOW +
              "Warning: module [{}] loading failed: {}".format(name, e) +
              Style.RESET_ALL)
Ejemplo n.º 3
0
def _get_cdll():
    global _CDLL
    if not _CDLL:
        # NOTE(ralonsoh): from https://docs.python.org/3.6/library/
        # ctypes.html#ctypes.PyDLL: "Instances of this class behave like CDLL
        # instances, except that the Python GIL is not released during the
        # function call, and after the function execution the Python error
        # flag is checked."
        # Check https://bugs.launchpad.net/neutron/+bug/1870352
        _CDLL = ctypes.PyDLL(ctypes_util.find_library('c'), use_errno=True)
    return _CDLL
Ejemplo n.º 4
0
def rtl(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    dll.InitializeRtl.restype = BOOL
    dll.InitializeRtl.argtypes = [
        PRTL,
        PULONG,
    ]

    return dll
Ejemplo n.º 5
0
def get_dll(version):
	"""returns a PyDLL for a specific python version"""
	if version == 2:
		for name in (OLD_PY2_FRAMEWORK, NEW_PY2_FRAMEWORK):
			path = os.path.join(EXE_DIR, "Frameworks", name + ".framework", name)
			if os.path.exists(path):
				return ctypes.PyDLL(path)
		raise RuntimeError("Could not load any Python 2 Framework!")
	elif version == 3:
		return ctypes.pythonapi
	else:
		raise ValueError("Unknown Python version: '{v}'!".format(v=version))
Ejemplo n.º 6
0
def profile(file, globals_obj, locals_obj, profdll):
    global profiler, pyprofdll

    pyprofdll = ctypes.PyDLL(profdll)
    profiler = pyprofdll.CreateProfiler(sys.dllhandle)

    handle = start_profiling()

    try:
        execfile(file, globals_obj, locals_obj)
    finally:
        pyprofdll.CloseThread(handle)
        pyprofdll.CloseProfiler(profiler)
Ejemplo n.º 7
0
def apply_dl_hacks():
    if have_ctypes_dlopen:
        setattr(ctypes, '_system_dlopen', ctypes._dlopen)

    if have_ctypes_util:
        ctypes.util._system_find_library = ctypes.util.find_library

        if hasattr(ctypes.util, '_findLib_gcc'):
            ctypes.util._findLib_gcc = lambda name: None
    else:
        ctypes_util = pupy.make_module('ctypes.util')

        setattr(ctypes_util, '_system_find_library', _find_library)

    ctypes._dlopen = _pupy_dlopen
    ctypes.util.find_library = _pupy_find_library

    libpython = None

    if sys.platform == 'win32':
        try:
            libpython = ctypes.PyDLL('python27.dll')
        except WindowsError:
            pupy.dprint('python27.dll not found')
    else:
        for libname in (None, 'libpython2.7.so.1.0', 'libpython2.7.so'):
            try:
                candidate = ctypes.PyDLL(libname)
            except OSError:
                continue

            if hasattr(candidate, '_Py_PackageContext'):
                libpython = candidate
                break

    if libpython is not None:
        pupy.dprint('Set ctypes.pythonapi to {}', libpython)
        ctypes.pythonapi = libpython
Ejemplo n.º 8
0
def config():
    if sys.platform.startswith("win"):
        return

    libdl = ctypes.CDLL(ctypes.util.find_library('dl'))
    libc = ctypes.PyDLL(None)

    class Dl_info(ctypes.Structure):
        _fields_ = (('dli_fname', ctypes.c_char_p),
                    ('dli_fbase', ctypes.c_void_p),
                    ('dli_sname', ctypes.c_char_p),
                    ('dli_saddr', ctypes.c_void_p))

    libdl.dladdr.argtypes = (ctypes.c_void_p, ctypes.POINTER(Dl_info))
    info = Dl_info()
    libdl.dladdr(libc.Py_IsInitialized, ctypes.byref(info))

    python = sys.executable
    libpython = info.dli_fname.decode()

    try:
        lib = ctypes.PyDLL(libpython)
    except OSError:
        libpython = ""
    else:
        if lib.Py_IsInitialized() == 0:
            libpython = ""

    try:
        import sysconfig
        pythonhome = sysconfig.get_config_vars('prefix')[0] + ":" + \
            sysconfig.get_config_vars('exec_prefix')[0]
    except Exception:
        pythonhome = None
    numpy = module_exists("numpy")

    return (python, libpython, pythonhome, numpy)
Ejemplo n.º 9
0
    def __init__(self, libjulia_path, bindir, sysimage):
        self.libjulia_path = libjulia_path
        self.bindir = bindir
        self.sysimage = sysimage

        if not os.path.exists(libjulia_path):
            raise RuntimeError("Julia library (\"libjulia\") not found! {}".format(libjulia_path))

        # fixes a specific issue with python 2.7.13
        # ctypes.windll.LoadLibrary refuses unicode argument
        # http://bugs.python.org/issue29294
        if sys.version_info >= (2, 7, 13) and sys.version_info < (2, 7, 14):
            libjulia_path = libjulia_path.encode("ascii")

        self.libjulia = ctypes.PyDLL(libjulia_path, ctypes.RTLD_GLOBAL)
        setup_libjulia(self.libjulia)
Ejemplo n.º 10
0
def join_all_spaces(qtwin):
    """Create a full-screen button on qtwin.
    The window needs to be already shown.
    """
    view = qtwin.effectiveWinId()
    print(view)
    print(dir(view))
    print(view.ascobject())
    cocoawin = send1(PyCObject_AsVoidPtr(view.ascobject()), window_sel)
    import ctypes, objc
    _objc = ctypes.PyDLL(objc._objc.__file__)
    _objc.PyObjCObject_New.restype = ctypes.py_object
    _objc.PyObjCObject_New.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int]
    def objc_object(id):
        return _objc.PyObjCObject_New(id, 0, 1)
    objc_object(cocoawin).setCollectionBehavior_(NSWindowCollectionBehaviorFullScreenAuxiliary |
                                                 NSWindowCollectionBehaviorCanJoinAllSpaces |
                                                 NSWindowCollectionBehaviorStationary)
Ejemplo n.º 11
0
def vspyprof(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    dll.CreateProfiler.restype = c_void_p
    dll.CreateCustomProfiler.restype = c_void_p
    dll.CreateCustomProfiler.argtypes = [c_void_p, ctypes.c_void_p]
    dll.CloseThread.argtypes = [c_void_p]
    dll.CloseProfiler.argtypes = [c_void_p]
    dll.InitProfiler.argtypes = [c_void_p]
    dll.InitProfiler.restype = c_void_p

    #dll.SetTracing.argtypes = [c_void_p]
    #dll.UnsetTracing.argtypes = [c_void_p]
    #dll.IsTracing.argtypes = [c_void_p]
    #dll.IsTracing.restype = c_bool

    return dll
Ejemplo n.º 12
0
def load_module(library_name, *args):
    ''' Load a module from a library and one or more module names.

    Args:
      *args: Module names.
    '''
    try:
        modules = []
        module_library = ctypes.PyDLL(library_name + "." + ext)
        for module_name in args:
            module = getattr(module_library, 'PyInit_' + module_name)
            module.restype = ctypes.py_object
            modules.append( module() )
        if len(modules) == 1:
            return modules[0]
        else:
            return tuple(modules)
    except:
        return None 
Ejemplo n.º 13
0
def tracer(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    dll.InitializeTraceStores.restype = BOOL
    dll.InitializeTraceStores.argtypes = [
        PRTL,
        PWSTR,
        PVOID,
        PDWORD,
        PDWORD,
    ]

    dll.InitializeTraceContext.restype = BOOL
    dll.InitializeTraceContext.argtypes = [
        PRTL,
        PTRACE_CONTEXT,
        PDWORD,
        PTRACE_SESSION,
        PTRACE_STORES,
        PVOID,
    ]

    dll.InitializeTraceSession.restype = BOOL
    dll.InitializeTraceSession.argtypes = [
        PRTL,
        PTRACE_SESSION,
        PDWORD
    ]

    dll.SubmitTraceStoreFileExtensionThreadpoolWork.restype = None
    dll.SubmitTraceStoreFileExtensionThreadpoolWork.argtypes = [ PTRACE_STORE, ]

    #dll.CallSystemTimer.restype = BOOL
    #dll.CallSystemTimer.argtypes = [
    #    PFILETIME,
    #    PVOID,
    #]

    return dll
Ejemplo n.º 14
0
def pythontracer(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    dll.InitializePythonTraceContext.restype = BOOL
    dll.InitializePythonTraceContext.argtypes = [
        PPYTHON_TRACE_CONTEXT, PULONG, PPYTHON, PTRACE_CONTEXT, PPYTRACEFUNC,
        PUSERDATA
    ]

    dll.StartTracing.restype = BOOL
    dll.StartTracing.argtypes = [
        PPYTHON_TRACE_CONTEXT,
    ]

    dll.StopTracing.restype = BOOL
    dll.StopTracing.argtypes = [
        PPYTHON_TRACE_CONTEXT,
    ]

    return dll
Ejemplo n.º 15
0
    def load_libjulia(self, config):
        if self._libjulia_loaded:
            return

        jlinfo = config.juliainfo()
        BINDIR, libjulia_path, image_file = jlinfo[:3]
        logger.debug("Base.Sys.BINDIR = %s", BINDIR)
        logger.debug("libjulia_path = %s", libjulia_path)
        if not os.path.exists(libjulia_path):
            raise RuntimeError(
                'Julia library ("libjulia") not found! {}'.format(
                    libjulia_path))

        self.julia_bindir = BINDIR.encode("utf-8")
        self.image_file = image_file

        # fixes a specific issue with python 2.7.13
        # ctypes.windll.LoadLibrary refuses unicode argument
        # http://bugs.python.org/issue29294
        if (2, 7, 13) <= sys.version_info < (2, 7, 14):
            libjulia_path = libjulia_path.encode("ascii")

        libjulia = ctypes.PyDLL(libjulia_path, ctypes.RTLD_GLOBAL)
        try:
            jl_init_with_image = libjulia.jl_init_with_image
        except AttributeError:
            try:
                jl_init_with_image = libjulia.jl_init_with_image__threading
            except AttributeError:
                raise RuntimeError(
                    "No libjulia entrypoint found! (tried jl_init_with_image"
                    " and jl_init_with_image__threading)")
        jl_init_with_image.argtypes = [c_char_p, c_char_p]

        self.jl_init_with_image = jl_init_with_image
        self._libjulia = libjulia

        self._libjulia_loaded = True
Ejemplo n.º 16
0
def ctypes_open(lib_name):
    import os
    import sys
    if sys.platform.startswith('darwin'):
        exts = ['.dylib', '.so']
    elif sys.platform.startswith('linux'):
        exts = ['.so']
    else:  # Windows
        exts = ['.pyd', '.dll']
        os.environ['PATH'] = os.environ['PATH'] \
            + ';' + os.path.join(os.path.dirname(__file__), 'lib')
    for ext in exts:
        if os.path.isabs(lib_name):
            lib_path = lib_name
        else:
            lib_path = os.path.join(os.path.dirname(__file__), lib_name)
        lib_path += ext
        if not os.path.exists(lib_path):
            continue
        lib = ctypes.PyDLL(lib_path)
        break
    else:
        raise RuntimeError("Unable to find '%s' shared library" % lib_name)
    return lib
Ejemplo n.º 17
0
  def __init__(self):
    moddir = os.path.dirname(os.path.abspath(__file__))
    # self._lib = ctypes.cdll.LoadLibrary('%s/libAks.so' % moddir)
    self._lib = ctypes.PyDLL('%s/libAks.so' % moddir)

    # AKS::SysManager* createSysManager();
    self._lib.createSysManagerExt.restype  = ctypes.c_void_p
    self._lib.createSysManagerExt.argtypes = []

    # void loadKernel(AKS::SysManager* sysMan, const char* kernelDir);
    self._lib.loadKernels.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    # void loadGraphs(AKS::SysManager* sysMan, const char* graphPath);
    self._lib.loadGraphs.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    # AKS::AIGraph* getGraph(AKS::SysManager* sysMan, const char* graphName);
    self._lib.getGraph.restype  = ctypes.c_void_p
    self._lib.getGraph.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

    # void enqueueJob(AKS::SysManager* sysMan, AKS::AIGraph* graph,
    #    const char* imagePath, AKS::NodeParams* params);
    self._lib.enqueueJob.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_void_p]

    # void waitForAllResults(AKS::SysManager* sysMan);
    self._lib.waitForAllResults.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    # void resetTimer(AKS::SysManager* sysMan);
    self._lib.resetTimer.argtypes = [ctypes.c_void_p]

    # void report(AKS::SysManager* sysMan, AKS::AIGraph* graph);
    self._lib.report.argtypes = [ctypes.c_void_p, ctypes.c_void_p]

    # void deleteSysManager(AKS::SysManager* sysMan);
    self._lib.deleteSysManagerExt.argtypes = []

    self._csysmgr = self._lib.createSysManagerExt()
Ejemplo n.º 18
0
# Minimal repl.c to support precompilation with python symbols already loaded
import ctypes
import sys
import os
from ctypes import *
if sys.platform.startswith('darwin'):
    sh_ext = ".dylib"
elif sys.platform.startswith('win32'):
    sh_ext = ".dll"
else:
    sh_ext = ".so"
libjulia_path = os.environ["PYCALL_LIBJULIA_PATH"] + "/lib" + os.environ[
    "PYCALL_JULIA_FLAVOR"] + sh_ext
libjulia = ctypes.PyDLL(libjulia_path, ctypes.RTLD_GLOBAL)
os.environ["JULIA_HOME"] = os.environ[
    "PYCALL_JULIA_HOME"]  # TODO: this can be removed when dropping Julia v0.6
os.environ["JULIA_BINDIR"] = os.environ["PYCALL_JULIA_HOME"]

if not hasattr(libjulia, "jl_init_with_image"):
    if hasattr(libjulia, "jl_init_with_image__threading"):
        libjulia.jl_init_with_image = libjulia.jl_init_with_image__threading
    else:
        raise ImportError(
            "No libjulia entrypoint found! (tried jl_init and jl_init__threading)"
        )

# Set up the calls from libjulia we'll use
libjulia.jl_parse_opts.argtypes = [POINTER(c_int), POINTER(POINTER(c_char_p))]
libjulia.jl_parse_opts.restype = None
libjulia.jl_init_with_image.argtypes = [c_char_p, c_char_p]
libjulia.jl_init_with_image.restype = None
Ejemplo n.º 19
0
# https://github.com/sosy-lab/benchexec
#
# SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
#
# SPDX-License-Identifier: Apache-2.0
"""This module contains function declarations for several functions of libc
(based on ctypes) and constants relevant for these functions.
"""

import ctypes as _ctypes
from ctypes import c_int, c_uint32, c_long, c_ulong, c_size_t, c_char_p, c_void_p
import os as _os

_libc = _ctypes.CDLL("libc.so.6", use_errno=True)
"""Reference to standard C library."""
_libc_with_gil = _ctypes.PyDLL("libc.so.6", use_errno=True)
"""Reference to standard C library, and we hold the GIL during all function calls."""


def _check_errno(result, func, arguments):
    assert func.restype in [c_int, c_void_p]
    if (func.restype == c_int and result
            == -1) or (func.restype == c_void_p
                       and c_void_p(result).value == c_void_p(-1).value):
        errno = _ctypes.get_errno()
        try:
            func_name = func.__name__
        except AttributeError:
            func_name = "__unknown__"
        msg = (func_name + "(" + ", ".join(map(str, arguments)) +
               ") failed: " + _os.strerror(errno))
Ejemplo n.º 20
0
    def __init__(self,
                 init_julia=True,
                 jl_runtime_path=None,
                 jl_init_path=None,
                 debug=False):
        """Create a Python object that represents a live Julia interpreter.

        Parameters
        ==========

        init_julia : bool
            If True, try to initialize the Julia interpreter. If this code is
            being called from inside an already running Julia, the flag should
            be passed as False so the interpreter isn't re-initialized.

        jl_runtime_path : str (optional)
            Path to your Julia binary, e.g. "/usr/local/bin/julia"

        jl_init_path : str (optional)
            Path to give to jl_init relative to which we find sys.so,
            (defaults to jl_runtime_path or NULL)

        debug : bool
            If True, print some debugging information to STDERR

        Note that it is safe to call this class constructor twice in the same
        process with `init_julia` set to True, as a global reference is kept
        to avoid re-initializing it. The purpose of the flag is only to manage
        situations when Julia was initialized from outside this code.
        """
        self.is_debugging = debug

        # Ugly hack to register the julia interpreter globally so we can reload
        # this extension without trying to re-open the shared lib, which kills
        # the python interpreter. Nasty but useful while debugging
        if _julia_runtime[0]:
            self.api = _julia_runtime[0]
            return

        self._debug()  # so that debug message is shown nicely w/ pytest

        if init_julia:
            if jl_runtime_path:
                runtime = jl_runtime_path
            else:
                runtime = 'julia'
            JULIA_HOME, libjulia_path, image_file, depsjlexe = juliainfo(
                runtime)
            self._debug("pyprogramname =", depsjlexe)
            self._debug("sys.executable =", sys.executable)
            exe_differs = is_different_exe(depsjlexe, sys.executable)
            self._debug("exe_differs =", exe_differs)
            self._debug("JULIA_HOME = %s,  libjulia_path = %s" %
                        (JULIA_HOME, libjulia_path))
            if not os.path.exists(libjulia_path):
                raise JuliaError(
                    "Julia library (\"libjulia\") not found! {}".format(
                        libjulia_path))

            # fixes a specific issue with python 2.7.13
            # ctypes.windll.LoadLibrary refuses unicode argument
            # http://bugs.python.org/issue29294
            if sys.version_info >= (2, 7, 13) and sys.version_info < (2, 7,
                                                                      14):
                libjulia_path = libjulia_path.encode("ascii")

            self.api = ctypes.PyDLL(libjulia_path, ctypes.RTLD_GLOBAL)
            if not jl_init_path:
                if jl_runtime_path:
                    jl_init_path = os.path.dirname(
                        os.path.realpath(jl_runtime_path)).encode("utf-8")
                else:
                    jl_init_path = JULIA_HOME.encode(
                        "utf-8")  # initialize with JULIA_HOME

            use_separate_cache = exe_differs or determine_if_statically_linked(
            )
            if use_separate_cache:
                PYCALL_JULIA_HOME = os.path.join(
                    os.path.dirname(os.path.realpath(__file__)),
                    "fake-julia").replace("\\", "\\\\")
                os.environ[
                    "JULIA_HOME"] = PYCALL_JULIA_HOME  # TODO: this line can be removed when dropping Julia v0.6
                os.environ["JULIA_BINDIR"] = PYCALL_JULIA_HOME
                jl_init_path = PYCALL_JULIA_HOME.encode("utf-8")

            if not hasattr(self.api, "jl_init_with_image"):
                if hasattr(self.api, "jl_init_with_image__threading"):
                    self.api.jl_init_with_image = self.api.jl_init_with_image__threading
                else:
                    raise ImportError(
                        "No libjulia entrypoint found! (tried jl_init_with_image and jl_init_with_image__threading)"
                    )
            self.api.jl_init_with_image.argtypes = [char_p, char_p]
            self._debug("calling jl_init_with_image(%s, %s)" %
                        (jl_init_path, image_file))
            self.api.jl_init_with_image(jl_init_path,
                                        image_file.encode("utf-8"))
            self._debug("seems to work...")

        else:
            # we're assuming here we're fully inside a running Julia process,
            # so we're fishing for symbols in our own process table
            self.api = ctypes.PyDLL('')

        # Store the running interpreter reference so we can start using it via self.call
        self.api.jl_.argtypes = [void_p]
        self.api.jl_.restype = None

        # Set the return types of some of the bridge functions in ctypes terminology
        self.api.jl_eval_string.argtypes = [char_p]
        self.api.jl_eval_string.restype = void_p

        self.api.jl_exception_occurred.restype = void_p
        self.api.jl_typeof_str.argtypes = [void_p]
        self.api.jl_typeof_str.restype = char_p
        self.api.jl_call2.argtypes = [void_p, void_p, void_p]
        self.api.jl_call2.restype = void_p
        self.api.jl_get_field.argtypes = [void_p, char_p]
        self.api.jl_get_field.restype = void_p
        self.api.jl_typename_str.restype = char_p
        self.api.jl_unbox_voidpointer.argtypes = [void_p]
        self.api.jl_unbox_voidpointer.restype = py_object

        self.api.jl_exception_clear.restype = None
        self.api.jl_stderr_obj.argtypes = []
        self.api.jl_stderr_obj.restype = void_p
        self.api.jl_stderr_stream.argtypes = []
        self.api.jl_stderr_stream.restype = void_p
        self.api.jl_printf.restype = ctypes.c_int
        self.api.jl_exception_clear()

        if init_julia:
            if use_separate_cache:
                # First check that this is supported
                self._call("""
                    if VERSION < v"0.5-"
                        error(\"""Using pyjulia with a statically-compiled version
                                  of python or with a version of python that
                                  differs from that used by PyCall.jl is not
                                  supported on julia 0.4""\")
                    end
                """)
                # Intercept precompilation
                os.environ["PYCALL_PYTHON_EXE"] = sys.executable
                os.environ["PYCALL_JULIA_HOME"] = PYCALL_JULIA_HOME
                os.environ["PYJULIA_IMAGE_FILE"] = image_file
                os.environ["PYCALL_LIBJULIA_PATH"] = os.path.dirname(
                    libjulia_path)
                # Add a private cache directory. PyCall needs a different
                # configuration and so do any packages that depend on it.
                self._call(
                    u"unshift!(Base.LOAD_CACHE_PATH, abspath(Pkg.Dir._pkgroot(),"
                    +
                    "\"lib\", \"pyjulia%s-v$(VERSION.major).$(VERSION.minor)\"))"
                    % sys.version_info[0])
                # If PyCall.ji does not exist, create an empty file to force
                # recompilation
                self._call(u"""
                    isdir(Base.LOAD_CACHE_PATH[1]) ||
                        mkpath(Base.LOAD_CACHE_PATH[1])
                    depsfile = joinpath(Base.LOAD_CACHE_PATH[1],"PyCall.ji")
                    isfile(depsfile) || touch(depsfile)
                """)

            self._call(u"using PyCall")
        # Whether we initialized Julia or not, we MUST create at least one
        # instance of PyObject and the convert function. Since these will be
        # needed on every call, we hold them in the Julia object itself so
        # they can survive across reinitializations.
        self.api.PyObject = self._call("PyCall.PyObject")
        self.api.convert = self._call("convert")

        # Flag process-wide that Julia is initialized and store the actual
        # runtime interpreter, so we can reuse it across calls and module
        # reloads.
        _julia_runtime[0] = self.api

        self.sprint = self.eval('sprint')
        self.showerror = self.eval('showerror')
    import numpy
except ImportError:
    raise Exception('MonetDBLite requires numpy but import of numpy failed')

try:
    import pandas
except ImportError:
    raise Exception('MonetDBLite requires pandas but importing pandas failed')

if os.name == 'nt':
    os.environ["PATH"] += os.pathsep + os.path.dirname(
        os.path.abspath(__file__))
# make mal_linker happy
os.environ["MONETDBLITE_LIBNAME"] = libs[0]
dll = ctypes.PyDLL(os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                libs[0]),
                   mode=ctypes.RTLD_GLOBAL)

dll.python_monetdblite_init.argtypes = []
dll.python_monetdblite_init.restype = None
dll.python_monetdblite_init()

dll.python_monetdb_init.argtypes = [ctypes.c_char_p, ctypes.c_int]
dll.python_monetdb_init.restype = ctypes.py_object

dll.python_monetdb_sql.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
dll.python_monetdb_sql.restype = ctypes.py_object

dll.python_monetdb_insert.argtypes = [
    ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.py_object
]
Ejemplo n.º 22
0
# coding: utf-8

import ctypes
import cairo  # pycairo
import cairocffi

pycairo = ctypes.PyDLL(cairo._cairo.__file__)
pycairo.PycairoContext_FromContext.restype = ctypes.c_void_p
pycairo.PycairoContext_FromContext.argtypes = 3 * [ctypes.c_void_p]
ctypes.pythonapi.PyList_Append.argtypes = 2 * [ctypes.c_void_p]


def _UNSAFE_cairocffi_context_to_pycairo(cairocffi_context):
    # Sanity check. Continuing with another type would probably segfault.
    if not isinstance(cairocffi_context, cairocffi.Context):
        raise TypeError('Expected a cairocffi.Context, got %r'
                        % cairocffi_context)

    # Create a reference for PycairoContext_FromContext to take ownership of.
    cairocffi.cairo.cairo_reference(cairocffi_context._pointer)
    # Casting the pointer to uintptr_t (the integer type as wide as a pointer)
    # gets the context’s integer address.
    # On CPython id(cairo.Context) gives the address to the Context type,
    # as expected by PycairoContext_FromContext.
    address = pycairo.PycairoContext_FromContext(
        int(cairocffi.ffi.cast('uintptr_t', cairocffi_context._pointer)),
        id(cairo.Context),
        None)
    assert address
    # This trick uses Python’s C API
    # to get a reference to a Python object from its address.
Ejemplo n.º 23
0
def magic_flush_mro_cache() -> None:
    ctypes.PyDLL(None).PyType_Modified(ctypes.py_object(object))
Ejemplo n.º 24
0
 def __init__(self, library_path):
     self._c_lib = ctypes.PyDLL(library_path)
Ejemplo n.º 25
0
# Copyright (c) Facebook, Inc. and its affiliates.
# SPDX-License-Identifier: GPL-3.0-or-later

import ctypes
import enum
from enum import auto
import os

import _drgn
import drgn

_drgn_pydll = ctypes.PyDLL(_drgn.__file__)
_drgn_cdll = ctypes.CDLL(_drgn.__file__)


class _drgn_error(ctypes.Structure):
    _fields_ = [
        ("code", ctypes.c_uint),
        ("errnum", ctypes.c_int),
        ("path", ctypes.c_char_p),
        ("msg", ctypes.c_char_p),
    ]


_drgn_pydll.set_drgn_error.restype = ctypes.c_void_p
_drgn_pydll.set_drgn_error.argtypes = [ctypes.POINTER(_drgn_error)]


def _check_err(err):
    if err:
        _drgn_pydll.set_drgn_error(err)
Ejemplo n.º 26
0
def sqlite3(path=None, dll=None):
    assert path or dll
    if not dll:
        dll = ctypes.PyDLL(path)

    return dll
Ejemplo n.º 27
0
    #-------------------
    # Repository module
    #-------------------
    #repository = load_module('lib_simvascular_repository', 'pyRepository')

    ## Remove the varialbles used here so they don't show up in the doc. 
    del ext 
    del load_module 


#----------------------------------------------------------
#                   Python 2.0
#----------------------------------------------------------

else:
    myDll=ctypes.PyDLL('lib_simvascular_solid.' + ext)
    myDll.initpySolid()
    import pySolid as Solid
    myDll=ctypes.PyDLL('lib_simvascular_polydata_solid.' + ext)
    myDll.initpySolidPolydata()
    import pySolidPolydata as SolidPolyData
    try:
        myDll=ctypes.PyDLL('lib_simvascular_parasolid_solid.' + ext)
        myDll.initpySolidParasolid()
        import pySolidParasolid as SolidParaSolid
    except:
        pass
    myDll=ctypes.PyDLL('lib_simvascular_repository.' + ext)
    myDll.initpyRepository()
    import pyRepository as Repository
Ejemplo n.º 28
0
IN_PYTHONISTA = sys.executable.find('Pythonista') >= 0

if IN_PYTHONISTA:
    import plistlib

    _properties = plistlib.readPlist(os.path.join(os.path.dirname(sys.executable), 'Info.plist'))
    PYTHONISTA_VERSION = _properties['CFBundleShortVersionString']
    PYTHONISTA_VERSION_LONG = _properties['CFBundleVersion']

    if PYTHONISTA_VERSION < '3.0':
        python_capi = ctypes.pythonapi
    else:
        # The default pythonapi always points to Python 3 in Pythonista 3
        # So we need to load the Python 2 API manually
        python_capi = ctypes.PyDLL(
            os.path.join(os.path.dirname(sys.executable),
                         'Frameworks/PythonistaKit.framework/PythonistaKit')
        )
else:
    PYTHONISTA_VERSION = '0.0'
    PYTHONISTA_VERSION_LONG = '000000'
    python_capi = ctypes.pythonapi

platform_string = platform.platform()

ON_IPAD = platform_string.find('iPad') >= 0
ON_IOS_8 = platform_string.split('-')[1].startswith('14')
M_64 = platform_string.find('64bit') != -1

CTRL_KEY_FLAG = (1 << 18)  # Control key for keyCommands
CMD_KEY_FLAG = (1 << 20)  # Command key
Ejemplo n.º 29
0
			wx.CallAfter(self.StupidMacOSWorkaround)

	def StupidMacOSWorkaround(self):
		"""
		On MacOS for some magical reason opening new frames does not work until you opened a new modal dialog and closed it.
		If we do this from software, then, as if by magic, the bug which prevents opening extra frames is gone.
		"""
		dlg = wx.Dialog(None)
		wx.PostEvent(dlg, wx.CommandEvent(wx.EVT_CLOSE.typeId))
		dlg.ShowModal()
		dlg.Destroy()

if platform.system() == "Darwin": #Mac magic. Dragons live here. THis sets full screen options.
	try:
		import ctypes, objc
		_objc = ctypes.PyDLL(objc._objc.__file__)

		# PyObject *PyObjCObject_New(id objc_object, int flags, int retain)
		_objc.PyObjCObject_New.restype = ctypes.py_object
		_objc.PyObjCObject_New.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int]

		def setFullScreenCapable(frame):
			frameobj = _objc.PyObjCObject_New(frame.GetHandle(), 0, 1)

			NSWindowCollectionBehaviorFullScreenPrimary = 1 << 7
			window = frameobj.window()
			newBehavior = window.collectionBehavior() | NSWindowCollectionBehaviorFullScreenPrimary
			window.setCollectionBehavior_(newBehavior)
	except:
		def setFullScreenCapable(frame):
			pass
Ejemplo n.º 30
0
from __future__ import print_function

import sys
import ctypes
import os


def trace(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)


ctypes.PyDLL("libgnucap.so", mode=ctypes.RTLD_GLOBAL)

oldflags = sys.getdlopenflags()
if (os.name == "posix"):
    # python tries to outsmart us, work around that
    trace("POSIX ON")
    sys.setdlopenflags(oldflags | ctypes.RTLD_GLOBAL)
    trace("PYDDL'd")
else:
    untested()

from .gnucap_swig import command, parse
trace("cmd imported")
from .c_comand import CMD, CMD_cmdproc, CMD_command
from .c_exp import eval
from .component import COMPONENT_ as COMPONENT
from .e_base import CKT_BASE_find_wave, CKT_BASE
from .e_cardlist import CARD_LIST
from .e_elemnt import ELEMENT
from .e_node import node_t