import os from ctypes import * os.add_dll_directory('D:\django projects\hy\znmx_project-master\Debug') dll = cdll.LoadLibrary('api.dll') ret = dll.setAlarm(2, 0) print(ret)
#=============================================================================== import platform if "Windows" in platform.system(): import os import sys import site current_path = os.path.dirname(__file__) path_to_env = site.getsitepackages()[0] path_to_libs = os.path.join(path_to_env, "Library", "bin") path_to_oneapi_backend = os.path.join(current_path, "oneapi") if sys.version_info.minor >= 8: if 'DALROOT' in os.environ: dal_root_redist = os.path.join(os.environ['DALROOT'], "redist", "intel64") if os.path.exists(dal_root_redist): os.add_dll_directory(dal_root_redist) os.environ['PATH'] = dal_root_redist + os.pathsep + os.environ['PATH'] os.add_dll_directory(path_to_libs) os.add_dll_directory(path_to_oneapi_backend) os.environ['PATH'] = path_to_libs + os.pathsep + os.environ['PATH'] try: from daal4py._daal4py import * from daal4py._daal4py import ( _get__version__, _get__daal_link_version__, _get__daal_run_version__, __has_dist__) except ImportError as e: s = str(e) if 'libfabric' in s:
__version__ = '0.3.5' # Windows support import os import sys extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs') if sys.platform == 'win32' and os.path.isdir(extra_dll_dir): if sys.version_info >= (3, 8): os.add_dll_directory(extra_dll_dir) else: os.environ.setdefault('PATH', '') os.environ['PATH'] += os.pathsep + extra_dll_dir from wfnsympy.WFNSYMLIB import mainlib, overlap_mat from wfnsympy.QSYMLIB import denslib, center_charge, build_density from wfnsympy.errors import MultiplicityError, ChangedAxisWarning, LabelNotFound from wfnsympy.optimize import minimize_axis, minimize_axis2, rotation_xy, rotation_axis from itertools import combinations import numpy as np _bohr_to_angstrom = 0.529177249 # define assignation of shell type to number and number of functions by shell shell_type_list = { '-1': ['sp', 4], '0': ['s', 1], '1': ['p', 3], '2': ['d', 6], '3': ['f', 10], '-2': ['d_', 5], # pure
"""SnapshotRequestTemplateExample.py""" from __future__ import print_function from __future__ import absolute_import import datetime from optparse import OptionParser, OptionValueError import os import platform as plat import sys if sys.version_info >= (3, 8) and plat.system().lower() == "windows": # pylint: disable=no-member with os.add_dll_directory(os.getenv('BLPAPI_LIBDIR')): import blpapi else: import blpapi def authOptionCallback(option, opt, value, parser): """Parse authorization options from user input""" vals = value.split('=', 1) if value == "user": authUser = blpapi.AuthUser.createWithLogonName() authOptions = blpapi.AuthOptions.createWithUser(authUser) elif value == "none": authOptions = None elif vals[0] == "app" and len(vals) == 2: appName = vals[1] authOptions = blpapi.AuthOptions.createWithApp(appName)
''' Created on 31.08.2020 @author: Georg Maubach ''' # Ab Python 3.8 müssen dlls als vertrauenswürdig markiert werden. # Deshalb ab 3.8.x von den unteren beiden Anweisungen den # Kommentar entfernen und den Pfad zum Projektverzeichnis # korrekt angeben import os os.add_dll_directory("D:\Selfcoding\WillmsBis040920\scara64anaconda") import ctypes Scara = ctypes.cdll.scara from my_scara_funcs import dreheRechts # alle Funktionen einbinden mit "*" Scara.starte(b"UndRechtsHerum") Scara.gehe() dreheRechts() Scara.gehe() Scara.gehe() dreheRechts() Scara.gehe() Scara.beende()
#Aim of this project is to learn communicating with APIs by creating an app that has access to my liked youtube videos to be played in tkinter GUI randomly. #Sadly, as this was first project I have done from scratch, I didn't think about how many URLs can youtube api return. Turns out, it's only 50 per page. import pafy import os os.add_dll_directory( r'C:\Program Files\VideoLAN\VLC') #path to VLC installation folder import yt import vlc import tkinter as tk def play(): url = yt.get_url() video = pafy.new(url) best = video.getbest() playurl = best.url Media = Instance.media_new(playurl) Media.get_mrl() player.set_media(Media) player.play() def stop(): player.stop() Instance = vlc.Instance() player = Instance.media_player_new() root = tk.Tk() tk.Button(root, text="play", command=play).pack()
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Starting from Python 3.8 DLL search policy has changed. # We need to add path to CUDA DLLs explicitly. import sys import os if os.name == 'nt': # Add CUDA_PATH env variable cuda_path = os.environ["CUDA_PATH"] if cuda_path: os.add_dll_directory(cuda_path) else: print("CUDA_PATH environment variable is not set.", file=sys.stderr) print("Can't set CUDA DLLs search path.", file=sys.stderr) exit(1) # Add PATH as well for minor CUDA releases sys_path = os.environ["PATH"] if sys_path: paths = sys_path.split(';') for path in paths: if os.path.isdir(path): os.add_dll_directory(path) else: print("PATH environment variable is not set.", file=sys.stderr) exit(1)
import os, openpyxl, time, pafy, vimeo_dl, validators, datetime, moviepy.editor, threading ### If you added vlc folder to your PATH just ncomment this try: os.add_dll_directory( openpyxl.load_workbook('PlayList.xlsx', data_only=True)['config'].cell(1, 2).value) except: print('no config sheet found or no path to vlc found in excel cell (1,2)') exit() ### import vlc YOUTUBE_PREFIX = 'https://www.youtube.com/' VIMEO_PREFIX = 'https://vimeo.com/' PATH_TO_EXCEL_FILE = 'PlayList.xlsx' VLC_INSTANCE = vlc.Instance( '--avcodec-hw=none --video-on-top --no-directx-hw-yuv') MEDIA_PLAYER = VLC_INSTANCE.media_player_new() DEFAULT_VLC_PATH = r'C:\Program Files (x86)\VideoLAN\VLC' DEFAULT_STATIC_PICTURE = 'https://i.ytimg.com/vi/2vv9IxwFVJY/maxresdefault.jpg' CONFIG_SHEET_NAME = 'config' WAITING_TIME_FOR_PLAYER_OPENING = 1.5 DATE_TIME_COLUMN = 1 TITLE_COLUMN = 2 LOCATION_COLUMN = 3 CONFIG_TITLE_COLUMN = 1 CONFIG_VALUE_COLUMN = 2 FIVE_DAYS = 5
#!/usr/bin/env python import ctypes import os from ctypes import * print("testing") dllname = 'kernel32.dll' dll = windll.LoadLibrary(dllname) print("load dll", dll) currpath = os.path.dirname(os.path.realpath(__file__)) print(currpath) os.add_dll_directory(currpath) dllname = "./native_lib.dll" dll = windll.LoadLibrary(dllname) print("load dll", dll) a = dll.testprint(b"abcdefg\n") print(type(a)) print(a) ret = c_int(0) param = c_int(199) pt = ctypes.c_void_p dll.create.restype = ctypes.c_void_p pt = dll.create(param, pointer(ret)) print("create ret {},pt {}:type{}".format(ret.value, pt, type(pt))) dll.call.argtypes = [ctypes.c_void_p, ctypes.c_char_p] ret = dll.call(pt, b"this is a test ") print("call: ", ret) dll.release.argtypes = [ctypes.c_void_p]
def _add_dll_dir(self, path): if path not in self._cached_dll_dirs: self._cached_dll_dirs.append(path) self._cached_added_dll_dirs.append(os.add_dll_directory(path))
of audio data and output the data to the soundcard yourself. FluidSynth works on all major platforms, so pyFluidSynth should also. ================================================================================ """ from ctypes import * from ctypes.util import find_library import os # A short circuited or expression to find the FluidSynth library # (mostly needed for Windows distributions of libfluidsynth supplied with QSynth) # DLL search method changed in Python 3.8 # https://docs.python.org/3/library/os.html#os.add_dll_directory if hasattr(os, 'add_dll_directory'): os.add_dll_directory(os.getcwd()) lib = find_library('fluidsynth') or \ find_library('libfluidsynth') or \ find_library('libfluidsynth-2') or \ find_library('libfluidsynth-1') if lib is None: raise ImportError("Couldn't find the FluidSynth library.") # Dynamically link the FluidSynth library # Architecture (32-/64-bit) must match your Python version _fl = CDLL(lib) # Helper function for declaring function prototypes def cfunc(name, result, *args):
"CUDNN_HOME"] if "CUDNN_HOME" in os.environ else os.environ[ cuda_env_variable] cudnn_bin_dir = os.path.join(cudnn_path, "bin") if not os.path.isfile( os.path.join(cudnn_bin_dir, f"cudnn64_{version_info.cudnn_version}.dll")): raise ImportError( f"cuDNN {version_info.cudnn_version} not installed in {cudnn_bin_dir}. " f"Set the CUDNN_HOME environment variable to the path of the 'cuda' directory " f"in your CUDNN installation if necessary.") if sys.version_info >= (3, 8): # Python 3.8 (and later) doesn't search system PATH when loading DLLs, so the CUDA location needs to be # specified explicitly using the new API introduced in Python 3.8. os.add_dll_directory(cuda_bin_dir) cuda_root = os.path.join(cuda_bin_dir, "..", "..") for root, _, files in os.walk(cuda_root): for f in files: if f == "cupti.lib": os.add_dll_directory(root) else: # Python 3.7 (and earlier) searches directories listed in PATH variable. # Make sure that the target CUDA version is at the beginning (important if multiple CUDA versions are # installed on the machine.) os.environ["PATH"] = cuda_bin_dir + os.pathsep + os.environ["PATH"] if version_info.vs2019 and platform.architecture()[0] == "64bit": if not os.path.isfile("C:\\Windows\\System32\\vcruntime140_1.dll"): raise ImportError( "Microsoft Visual C++ Redistributable for Visual Studio 2019 not installed on the machine."
def _setupQtDirectories(): # On Windows we need to explicitly import the shiboken6 module so # that the libshiboken.dll dependency is loaded by the time a # Qt module is imported. Otherwise due to PATH not containing # the shiboken6 module path, the Qt module import would fail # due to the missing libshiboken dll. # In addition, as of Python 3.8, the shiboken package directory # must be added to the DLL search paths so that shiboken6.dll # is found. # We need to do the same on Linux and macOS, because we do not # embed rpaths into the PySide6 libraries that would point to # the libshiboken library location. Importing the module # loads the libraries into the process memory beforehand, and # thus takes care of it for us. pyside_package_dir = os.path.abspath(os.path.dirname(__file__)) if sys.platform == 'win32' and sys.version_info[ 0] == 3 and sys.version_info[1] >= 8: for dir in _additional_dll_directories(pyside_package_dir): os.add_dll_directory(dir) try: import shiboken6 except Exception: paths = ', '.join(sys.path) print(f"PySide6/__init__.py: Unable to import shiboken6 from {paths}", file=sys.stderr) raise # Trigger signature initialization. try: # PYSIDE-829: Avoid non-existent attributes in compiled code (Nuitka). # We now use an explicit function instead of touching a signature. _init_pyside_extension() except AttributeError: stars = 79 * "*" print(dedent(f'''\ {stars} PySide6/__init__.py: The `signature` module was not initialized. This libshiboken module was loaded from "{shiboken6.__file__}". Please make sure that this is the real shiboken6 binary and not just a folder. {stars} '''), file=sys.stderr) raise if sys.platform == 'win32': # PATH has to contain the package directory, otherwise plugins # won't be able to find their required Qt libraries (e.g. the # svg image plugin won't find Qt5Svg.dll). os.environ[ 'PATH'] = pyside_package_dir + os.pathsep + os.environ['PATH'] # On Windows, add the PySide6\openssl folder (created by setup.py's # --openssl option) to the PATH so that the SSL DLLs can be found # when Qt tries to dynamically load them. Tell Qt to load them and # then reset the PATH. openssl_dir = os.path.join(pyside_package_dir, 'openssl') if os.path.exists(openssl_dir): path = os.environ['PATH'] try: os.environ['PATH'] = openssl_dir + os.pathsep + path try: from . import QtNetwork except ImportError: pass else: QtNetwork.QSslSocket.supportsSsl() finally: os.environ['PATH'] = path
class Network: if os.name == 'nt': os.add_dll_directory("${CUDAToolkit_BIN_DIR}") os.add_dll_directory("${GPUPoly_BINARY_DIR}") _lib = ctypes.cdll.LoadLibrary(ctypes.util.find_library('gpupoly')) else: # _lib=ctypes.cdll.LoadLibrary('${GPUPoly_BINARY_DIR}/dpGPUlib.so.0.10') _lib = ctypes.cdll.LoadLibrary('libgpupoly.so') def _nullable_ndptr(*args, **kwargs): base = np.ctypeslib.ndpointer(*args, **kwargs) def from_param(cls, obj): if obj is None: return obj return base.from_param(obj) return type(base.__name__, (base, ), {'from_param': classmethod(from_param)}) _lib.create.argtypes = [ctypes.c_int] _lib.create.restype = ctypes.c_void_p _lib.test_d.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float64, ndim=1), np.ctypeslib.ndpointer(dtype=np.float64, ndim=1), ctypes.c_int, ctypes.c_bool ] _lib.test_d.restype = ctypes.c_bool _lib.test_s.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float32, ndim=1), np.ctypeslib.ndpointer(dtype=np.float32, ndim=1), ctypes.c_int, ctypes.c_bool ] _lib.test_s.restype = ctypes.c_bool _lib.setLayerBox_d.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float64, ndim=1), np.ctypeslib.ndpointer(dtype=np.float64, ndim=1), ctypes.c_int ] _lib.setLayerBox_d.restype = None _lib.setLayerBox_s.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float32, ndim=1), np.ctypeslib.ndpointer(dtype=np.float32, ndim=1), ctypes.c_int ] _lib.setLayerBox_s.restype = None _lib.relax_s.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_bool, ctypes.c_bool ] _lib.relax_s.restype = None _lib.relax_d.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_bool, ctypes.c_bool ] _lib.relax_d.restype = None _lib.evalAffineExpr_d.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float64, ndim=2), ctypes.c_int, ctypes.c_int, _nullable_ndptr(dtype=np.float64, ndim=2, flags='C_CONTIGUOUS'), _nullable_ndptr(dtype=np.float64, ndim=1), ctypes.c_int, ctypes.c_bool ] _lib.evalAffineExpr_d.restype = None _lib.evalAffineExpr_s.argtypes = [ ctypes.c_void_p, np.ctypeslib.ndpointer(dtype=np.float32, ndim=2), ctypes.c_int, ctypes.c_int, _nullable_ndptr(dtype=np.float32, ndim=2, flags='C_CONTIGUOUS'), _nullable_ndptr(dtype=np.float32, ndim=1), ctypes.c_int, ctypes.c_bool ] _lib.evalAffineExpr_s.restype = None _lib.getOutputSize.argtypes = [ctypes.c_void_p, ctypes.c_int] _lib.getOutputSize.restype = ctypes.c_int _lib.clean.argtypes = [ctypes.c_void_p] _lib.clean.restype = None _lib.addLinear_d.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_int, np.ctypeslib.ndpointer(dtype=np.float64, ndim=2, flags='C_CONTIGUOUS') ] _lib.addLinear_s.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_int, np.ctypeslib.ndpointer(dtype=np.float32, ndim=2, flags='C_CONTIGUOUS') ] _lib.addConv2D_d.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_bool, ctypes.c_int, ctypes.c_int * 2, ctypes.c_int * 4, ctypes.c_int * 2, ctypes.c_int * 2, np.ctypeslib.ndpointer(dtype=np.float64, ndim=4, flags='C_CONTIGUOUS') ] _lib.addConv2D_s.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_bool, ctypes.c_int, ctypes.c_int * 2, ctypes.c_int * 4, ctypes.c_int * 2, ctypes.c_int * 2, np.ctypeslib.ndpointer(dtype=np.float32, ndim=4, flags='C_CONTIGUOUS') ] _lib.addBias_d.argtypes = [ ctypes.c_void_p, ctypes.c_int, np.ctypeslib.ndpointer(dtype=np.float64, ndim=1) ] _lib.addBias_s.argtypes = [ ctypes.c_void_p, ctypes.c_int, np.ctypeslib.ndpointer(dtype=np.float32, ndim=1) ] _lib.addReLU.argtypes = [ctypes.c_void_p, ctypes.c_int] _lib.addMaxPool2D.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_bool, ctypes.c_int * 2, ctypes.c_int * 4, ctypes.c_int * 2, ctypes.c_int * 2 ] _lib.addParSum.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int] _lib.addConcat.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int] NO_BACKSUBSTITUTION = 0 FULL_BACKSUBSTITUTION = 1 BACKSUBSTITUTION_WHILE_CONTAINS_ZERO = 2 ## Constructor # # Construct a new neural network to verify. # @param inputSize Number of elements of the input layer. def __init__(self, input_size): self._nn = self._lib.create(input_size) self.input_size = input_size self._last_layer_id = 0 ## Removes all layers of the network. def clean(self): if self._nn is not None: self._lib.clean(self._nn) self._nn = None ## Destructor def __del__(self): self.clean() ## Verifies an image # # Checks if an image (or more precisely, an input box) entirely classifies as a given label # Once this function has been called with a network, no additional layer should be added (i.e. it is necessary to clean and recreate a network) # It is of course possible to call this function multiple times on the same network. # # \param down A numpy array of inputSize doubles that represent the lower bound of the box # \param up A numpy array of inputSize doubles that represent the upper bound of the box # \param label Label in which the image is supposed to classify # \param soundness Whether to use sound arithmetic. # \returns whether the difference between the output logits wrt L_oo ball. def test(self, down, up, label, soundness=True): self.setLayerBox(down, up) # Set input layer concrete bounds # creates a matrix that computes the difference with the expected layer. diffMatrix = np.delete( -np.eye(self._lib.getOutputSize(self._nn, self._last_layer_id)), label, 0) diffMatrix[:, label] = 1 diffMatrix = diffMatrix.astype(self._last_dtype) # relax all layers, using simple interval analysis first. for i in range(self._last_layer_id): self.relax(i + 1, soundness=soundness, refineActivationsInput=False) # Evaluates an expression that computes the difference between expected label and each element of the output layer res = self.evalAffineExpr( diffMatrix, back_substitute=self.BACKSUBSTITUTION_WHILE_CONTAINS_ZERO, sound=soundness) #print("res1 ", res) if (res > 0).all(): # Expected layer is higher than all others return res # We failed to verify, so we redo the analysis with backsubstitution before activation layer. for i in range(self._last_layer_id): self.relax(i + 1, soundness=soundness) res = self.evalAffineExpr( diffMatrix, back_substitute=self.BACKSUBSTITUTION_WHILE_CONTAINS_ZERO, sound=soundness) #print("res2 ", res) return res def test_old(self, down, up, label, soundness=True): down = down.flatten() up = up.flatten() assert down.shape == (self.input_size, ) assert up.shape == (self.input_size, ) assert up.dtype == down.dtype if up.dtype == np.float64: return self._lib.test_d(self._nn, down, up, label, soundness) return self._lib.test_s(self._nn, down, up, label, soundness) ## Sets the concrete bounds of a layer. # # \param down A numpy array represents the lower bound of the box. Must have the size of the layer. # \param up A numpy array represents the upper bound of the box. Must have the size of the layer. # \param layer Index of the layer (by default, sets the input box). def setLayerBox(self, down, up, layer=0): down = down.flatten() up = up.flatten() assert up.dtype == down.dtype self._last_dtype = up.dtype if up.dtype == np.float64: return self._lib.setLayerBox_d(self._nn, down, up, layer) return self._lib.setLayerBox_s(self._nn, down, up, layer) ## Propagates forward the concrete bounds by interval analysis. Activation layers have their approximation models computed. # # \param layer Index of the layer # \param refineActivationsInput If true, and layer is an activation layer, then the input is first refined first via the appropriate back-substitution. # \param soundness Whether to use sound (but slower) arithmetic. # \param dtype Datatype of the concrete bounds to be used. Can be np.float32, np.float64, or None, in which case it uses the same type as the last setLayerBox. def relax(self, layer, refineActivationsInput=True, soundness=True, dtype=None): if dtype is None: dtype = self._last_dtype if dtype == np.float64: self._lib.relax_d(self._nn, layer, refineActivationsInput, soundness) else: self._lib.relax_s(self._nn, layer, refineActivationsInput, soundness) ## Evaluate the concrete bounds of a list of affine expressions. # # Evaluate the concrete bounds of a list of m affine expressions of the neurons of a given layer via back-substitution. # The affine expressions have the form Ax+b, where A is a m*n matrix, b a vector of size m, and x represents the n neurons of the layer layerId. # \param a A numpy array of dimension [m,n]. If None, equivalent to the identity. # \param b A numpy array of dimension [m]. If None, equivalent to a zero vector. # \param layer Index of the layer # \param back_substitute If set to FULL_BACKSUBSITUTION, back-substitution is always performed back to the inputs. If set to BACKSUBSTITUTION_WHILE_CONTAINS_ZERO, the backsubstitution is stopped as soon as 0 is not within the concrete bounds anymore. If set to NO_BACKSUBSTITUTION, only use the current concrete bounds of the layer. # \param sound If True, use floating-point sound arithmetic (slower). # \param dtype Datatype of the concrete bounds to be used. Can be np.float32, np.float64, or None, in which case it uses the same type as the last setLayerBox. # \returns A numpy array of size [m,2] containing the concrete bounds. def evalAffineExpr(self, a=None, b=None, layer=None, back_substitute=NO_BACKSUBSTITUTION, sound=True, dtype=None): if layer is None: layer = self._last_layer_id if dtype is None: dtype = self._last_dtype n = self._lib.getOutputSize(self._nn, layer) if a is None: m = n else: assert a.ndim == 2 assert a.dtype == dtype m = a.shape[0] a = np.ascontiguousarray(a) if b is not None: assert b.shape == (m, ) assert b.dtype == dtype res = np.ascontiguousarray(np.ndarray((m, 2), dtype=dtype)) if dtype == np.float64: self._lib.evalAffineExpr_d(self._nn, res, layer, m, a, b, back_substitute, sound) else: self._lib.evalAffineExpr_s(self._nn, res, layer, m, a, b, back_substitute, sound) return np.reshape(res, (m, 2)) ## Fully connected linear layer # # Adds a dense linear layer (without activation nor bias). If x is a column vector representing the input of the layer, the output is A*x. # # \param A Numpy matrix that represents A. A has outputSize rows, and its number of columns equals the parent outputSize. # \param parent Index of the parent layer (or 0 for the input layer). It can be None, in which case the parent is the last added layer. # \returns the index of the newly created layer. def add_linear(self, a, parent=None): if parent is None: parent = self._last_layer_id assert a.ndim == 2 output_size = a.shape[0] if a.dtype == np.float64: self._last_layer_id = self._lib.addLinear_d( self._nn, parent, output_size, np.ascontiguousarray(a)) else: self._last_layer_id = self._lib.addLinear_s( self._nn, parent, output_size, np.ascontiguousarray(a)) return self._last_layer_id ## ReLU layer # # Adds a ReLU layer to the network. # # \param parent Index of the parent layer (or 0 for the input layer). It can be None, in which case the parent is the last added layer. # \returns the index of the newly created layer. def add_relu(self, parent=None): if parent is None: parent = self._last_layer_id self._last_layer_id = self._lib.addReLU(self._nn, parent) return self._last_layer_id ## Bias layer # # Adds a Bias layer to the network, i.e. a layer that adds a constant vector to its input. # # \param parent Index of the parent layer (or 0 for the input layer). It can be None, in which case the parent is the last added layer. # \returns the index of the newly created layer. def add_bias(self, b, parent=None): if parent is None: parent = self._last_layer_id assert b.ndim == 1 if b.dtype == np.float64: self._last_layer_id = self._lib.addBias_d(self._nn, parent, b) else: self._last_layer_id = self._lib.addBias_s(self._nn, parent, b) return self._last_layer_id ## Convolution layer # # Adds a convolution layer, without activation nor bias. # # \param input_rows Dimension of the input. # \param input_cols Dimension of the input. # \param conv Convolution coefficients, given as a 4 dimensions numpy array (in order [row, column, channel, filter]. # \param channels_first If true, the layer expects input with the shape [batch, channel, row, col], and its output has the shape [batch, filter, row, col]. If false, the layer expects input with the shape [batch, row, col, channel], and its output has the shape [batch, row, col, filter]. # \param batches Number of batches. # \param strides An integer or a list of two integers, indicating the stride shape (respectively the number of rows and columns if a list). # \param padding An integer or a list of two integers, indicating the padding (respectively the number of pixels to add at the top and bottom, and the number of pixels to add on the left and right). # \param parent Index of the parent layer (or 0 for the input layer). It can be None, in which case the parent is the last added layer. # \returns the index of the newly created layer. def add_conv_2d(self, input_rows, input_cols, conv, channel_first=True, batches=1, strides=1, padding=0, parent=None): if parent is None: parent = self._last_layer_id assert conv.ndim == 4 kernel = conv.shape[0:2] input_shape = [batches, input_rows, input_cols, conv.shape[2]] filters = conv.shape[3] if not isinstance(strides, list): strides = [strides, strides] if not isinstance(padding, list): padding = [padding, padding] if conv.dtype == np.float64: self._last_layer_id = self._lib.addConv2D_d( self._nn, parent, channel_first, filters, (ctypes.c_int * 2)(*kernel), (ctypes.c_int * 4)(*input_shape), (ctypes.c_int * 2)(*strides), (ctypes.c_int * 2)(*padding), np.ascontiguousarray(conv)) else: self._last_layer_id = self._lib.addConv2D_s( self._nn, parent, channel_first, filters, (ctypes.c_int * 2)(*kernel), (ctypes.c_int * 4)(*input_shape), (ctypes.c_int * 2)(*strides), (ctypes.c_int * 2)(*padding), np.ascontiguousarray(conv)) return self._last_layer_id ## MaxPool2D layer. # # Adds a max pooling layer. # # \param pool Pool shape (Python list of 2 integers, respectively the number of rows and columns). # \param input_rows Dimension of the input. # \param input_cols Dimension of the input. # \param channels Number of channels. # \param channels_first If true, the layer expects input with the shape [batch, channel, row, col], and its output has the shape [batch, filter, row, col]. If false, the layer expects input with the shape [batch, row, col, channel], and its output has the shape [batch, row, col, filter]. # \param batches Number of batches. # \param strides An integer or a list of two integers, indicating the stride shape (respectively the number of rows and columns if a list). # \param padding An integer or a list of two integers, indicating the padding (respectively the number of pixels to add at the top and bottom, and the number of pixels to add on the left and right). # \param parent Index of the parent layer (or 0 for the input layer). It can be None, in which case the parent is the last added layer. # \returns the index of the newly created layer. def add_maxpool_2d(self, pool, input_rows, input_cols, channels, channel_first=True, batches=1, strides=None, padding=0, parent=None): if parent is None: parent = self._last_layer_id if not isinstance(pool, list): pool = [pool, pool] if strides is None: strides = pool elif not isinstance(strides, list): strides = [strides, strides] if not isinstance(padding, list): padding = [padding, padding] input_shape = [batches, input_rows, input_cols, channels] self._last_layer_id = self._lib.addMaxPool2D( self._nn, parent, channel_first, (ctypes.c_int * 2)(*pool), (ctypes.c_int * 4)(*input_shape), (ctypes.c_int * 2)(*strides), (ctypes.c_int * 2)(*padding)) return self._last_layer_id ## ParSum layer. # # Adds a "ParSum" layer, i.e. a layer that sums up the result of two previous layers. # \param parent1 Index of the first parent layer. # \param parent2 Index of the second parent layer. # \returns the index of the newly created layer. def add_parsum(self, parent1, parent2): self._last_layer_id = self._lib.addParSum(self._nn, parent1, parent2) return self._last_layer_id ## Concatenation layer. # # Adds a concatenation layer (like the one we can find in skipnets). It concatenates the result of two previous layers. # \param parent1 Index of the first parent layer. # \param parent2 Index of the second parent layer. # \returns the index of the newly created layer. def add_concat(self, parent1, parent2): self._last_layer_id = self._lib.addConcat(self._nn, parent1, parent2) return self._last_layer_id
if os.path.exists(current_path + os.sep + 'core_avx.' + core_suffix): has_avx_core = True if os.path.exists(current_path + os.sep + 'core_noavx.' + core_suffix): has_noavx_core = True try: if os.name == 'nt': third_lib_path = current_path + os.sep + '..' + os.sep + 'libs' os.environ['path'] = third_lib_path + ';' + os.environ['path'] sys.path.insert(0, third_lib_path) # Note: from python3.8, PATH will not take effect # https://github.com/python/cpython/pull/12302 # Use add_dll_directory to specify dll resolution path if sys.version_info[:2] >= (3, 8): os.add_dll_directory(third_lib_path) except ImportError as e: from .. import compat as cpt if os.name == 'nt': executable_path = os.path.abspath(os.path.dirname(sys.executable)) raise ImportError( """NOTE: You may need to run \"set PATH=%s;%%PATH%%\" if you encounters \"DLL load failed\" errors. If you have python installed in other directory, replace \"%s\" with your own directory. The original error is: \n %s""" % (executable_path, executable_path, cpt.get_exception_message(e))) else: raise ImportError( """NOTE: You may need to run \"export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH\" if you encounters \"libmkldnn.so not found\" errors. If you have python
#!python import os import sys import subprocess import numpy from math import * pathToTrelis = "/home/christopher/trelis/cubit_build/claro/bin" sys.path.append(pathToTrelis) if os.name == 'nt': binPath = pathToTrelis #os.path.dirname(os.path.abspath(__file__)) acisPath = r"/acis/code/bin" try: os.add_dll_directory(binPath + acisPath) except AttributeError: os.environ['path'] += ';' + binPath + acisPath import cubit cubit.init(['cubit', '-nobanner', '-nographics']) def main(paramFile, objFile): x, y = readParamFile(paramFile) status, bc_xyz, num_elem, nlcon = makeGeometry(x, y) if status != False: error_handle(objFile, nlcon, "makeGeometry") return status = buildUSpline(2, 1) if status != False:
(through custom forces and integrators), openness, and high performance (especially on recent GPUs) that make it truly unique among simulation codes. """ from __future__ import absolute_import __author__ = "Peter Eastman" import os, os.path import sys from . import version if sys.platform == 'win32': _path = os.environ['PATH'] os.environ['PATH'] = '%(lib)s;%(lib)s\plugins;%(path)s' % { 'lib': version.openmm_library_path, 'path': _path} try: with os.add_dll_directory(version.openmm_library_path): from . import _openmm except: pass from openmm.openmm import * from openmm.vec3 import Vec3 from openmm.mtsintegrator import MTSIntegrator, MTSLangevinIntegrator from openmm.amd import AMDIntegrator, AMDForceGroupIntegrator, DualAMDIntegrator if os.getenv('OPENMM_PLUGIN_DIR') is None and os.path.isdir(version.openmm_library_path): pluginLoadedLibNames = Platform.loadPluginsFromDirectory(os.path.join(version.openmm_library_path, 'plugins')) else: pluginLoadedLibNames = Platform.loadPluginsFromDirectory(Platform.getDefaultPluginsDirectory()) if sys.platform == 'win32':
+ "\n".join(msg[-2:])) try: f = open("errorLog.txt", "a") f.writelines(msg) f.close() except: pass os._exit(1) sys.excepthook = exchandler #Python3.8対応 #dllやモジュールをカレントディレクトリから読み込むように設定 if sys.version_info.major >= 3 and sys.version_info.minor >= 8: os.add_dll_directory(os.path.dirname(os.path.abspath(__file__))) sys.path.append(os.path.dirname(os.path.abspath(__file__))) import app as application import globalVars def main(): try: if os.path.exists("errorLog.txt"): os.remove("errorLog.txt") except: pass app = application.Main() globalVars.app = app app.initialize()
import rospkg import os if "add_dll_directory" in dir(os): rospack = rospkg.RosPack() rosbinpaths = set([ os.path.abspath( os.path.join(rospack.get_path(pkgname), os.pardir, os.pardir, "bin")) for pkgname in ["cv_bridge", "rosbag"] ]) for path in rosbinpaths: os.add_dll_directory(path) vcpkg_bin_dir = os.getenv("VCPKG_BIN_DIR") if vcpkg_bin_dir is not None: os.add_dll_directory(vcpkg_bin_dir) import rosbag import yaml from ackermann_msgs.msg import AckermannDrive, AckermannDriveStamped from nav_msgs.msg import Odometry from sensor_msgs.msg import LaserScan, LaserEcho, Image, CompressedImage import argparse import TimestampedImage_pb2, TimestampedPacketMotionData_pb2, Image_pb2, FrameId_pb2, MultiAgentLabel_pb2, LaserScan_pb2 import Pose3d_pb2, Vector3dStamped_pb2 from tqdm import tqdm as tqdm import rospy from rospy import Time import numpy as np, scipy import scipy, scipy.integrate, scipy.interpolate from scipy.spatial.transform import Rotation as Rot, RotationSpline as RotSpline import matplotlib from matplotlib import pyplot as plt
# however, we also started to receive reports of problems with DLL # resolution with Python 3.7 that were sometimes alleviated with # inclusion of the _distributor_init.py module; see SciPy main # repo gh-11826 # we noticed in scipy-wheels repo gh-70 that inclusion of # _distributor_init.py in 32-bit wheels for Python 3.7 resulted # in failures in DLL resolution (64-bit 3.7 did not) # as a result, we decided to combine both the old (working directory) # and new (absolute path to DLL location) DLL resolution mechanisms # to improve the chances of resolving DLLs across a wider range of # Python versions # we did not experiment with manipulating the PATH environment variable # to include libs_path; it is not immediately clear if this would have # robustness or security advantages over changing working directories # as done below # for python 3.8, the WinDLL loading doesn't work. Try add_dll_directory if sys.version_info[:2] == (3, 8): os.add_dll_directory(libs_path) else: try: owd = os.getcwd() os.chdir(libs_path) for filename in glob.glob(os.path.join(libs_path, '*dll')): WinDLL(os.path.abspath(filename)) finally: os.chdir(owd)
def find_lib_path(prefix='libmxnet'): """Find MXNet dynamic library files. Returns ------- lib_path : list(string) List of all found path to the libraries. """ lib_from_env = os.environ.get('MXNET_LIBRARY_PATH') if lib_from_env: if os.path.isfile(lib_from_env): if not os.path.isabs(lib_from_env): logging.warning( "MXNET_LIBRARY_PATH should be an absolute path, instead of: %s", lib_from_env) else: if os.name == 'nt': os.environ['PATH'] = os.environ[ 'PATH'] + ';' + os.path.dirname(lib_from_env) return [lib_from_env] else: logging.warning("MXNET_LIBRARY_PATH '%s' doesn't exist", lib_from_env) curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__))) api_path = os.path.join(curr_path, '../../lib/') cmake_build_path = os.path.join(curr_path, '../../build/') dll_path = [curr_path, api_path, cmake_build_path] if os.name == 'nt': dll_path.append(os.path.join(curr_path, '../../build')) vs_configuration = 'Release' if platform.architecture()[0] == '64bit': dll_path.append( os.path.join(curr_path, '../../build', vs_configuration)) dll_path.append( os.path.join(curr_path, '../../windows/x64', vs_configuration)) else: dll_path.append( os.path.join(curr_path, '../../build', vs_configuration)) dll_path.append( os.path.join(curr_path, '../../windows', vs_configuration)) elif os.name == "posix" and os.environ.get('LD_LIBRARY_PATH', None): dll_path[0:0] = [ p.strip() for p in os.environ['LD_LIBRARY_PATH'].split(":") ] if os.name == 'nt': os.environ['PATH'] = os.path.dirname( __file__) + ';' + os.environ['PATH'] dll_path = [os.path.join(p, prefix + '.dll') for p in dll_path] elif platform.system() == 'Darwin': dll_path = [os.path.join(p, prefix + '.dylib') for p in dll_path] + \ [os.path.join(p, prefix + '.so') for p in dll_path] else: dll_path.append('../../../') dll_path = [os.path.join(p, prefix + '.so') for p in dll_path] lib_path = [p for p in dll_path if os.path.exists(p) and os.path.isfile(p)] if len(lib_path) == 0: raise RuntimeError('Cannot find the MXNet library.\n' + 'List of candidates:\n' + str('\n'.join(dll_path))) if os.name == 'nt': os.environ['PATH'] = os.environ['PATH'] + ';' + os.path.dirname( lib_path[0]) if sys.version_info >= (3, 8): if 'CUDA_PATH' not in os.environ: raise RuntimeError( 'Cannot find the env CUDA_PATH.Please set CUDA_PATH env with cuda path' ) os.add_dll_directory(os.path.dirname(lib_path[0])) os.add_dll_directory(os.path.join(os.environ['CUDA_PATH'], 'bin')) return lib_path
from .get_winfsp_dir import get_winfsp_bin_dir, get_winfsp_library_name # WinFSP's DLL is not available system-wide, so we have to first retrieve it # (using either user-provided environ variable or the infamous windows # registry) and use the dedicated python call `os.add_dll_directory` # to add the `bin` path to the DLL search path. If the python version is lower # than 3.8, `os.add_dll_directory` is not available and we have to fallback # to the old way of adding a dll directory: customize the PATH environ # variable. WINFSP_BIN_DIR = get_winfsp_bin_dir() # Modifiy %PATH% in any case as it is used by `ctypes.util.find_library` os.environ["PATH"] = f"{WINFSP_BIN_DIR};{os.environ.get('PATH')}" if sys.version_info >= (3, 8): os.add_dll_directory(WINFSP_BIN_DIR) if not find_library(get_winfsp_library_name()): raise RuntimeError( f"The WinFsp DLL could not be found in {WINFSP_BIN_DIR}") try: from ._bindings import ffi, lib # noqa except Exception as exc: raise RuntimeError(f"The winfsp binding could not be imported\n{exc}") def enable_debug_log(): stderr_handle = lib.GetStdHandle(lib.STD_ERROR_HANDLE) lib.FspDebugLogSetHandle(stderr_handle)
if not os.path.isfile(sofa_file_test): print( "Warning: environment variable SOFA_ROOT is set but seems invalid.", "Loading SOFA libraries will likely fail.") print("SOFA_ROOT is currently: " + sofa_root) if not os.path.isfile(sofapython3_file_test): print("Warning: cannot find SofaPython3.dll at path: " + sofapython3_bin_path) print("This path will NOT be added to the DLL search path.", "Loading SofaPython3 python modules will likely fail.") if sys.version_info.minor >= 8: # Starting from python3.8 we need to explicitly find SOFA libraries if os.path.isfile(sofa_file_test): os.add_dll_directory(sofa_bin_path) if os.path.isfile(sofapython3_file_test): os.add_dll_directory(sofapython3_bin_path) else: # Add temporarily the bin/lib path to the env variable PATH if os.path.isfile(sofa_file_test): os.environ[ 'PATH'] = sofa_bin_path + os.pathsep + os.environ['PATH'] if os.path.isfile(sofapython3_file_test): os.environ[ 'PATH'] = sofapython3_bin_path + os.pathsep + os.environ['PATH'] print("---------------------------------------") sys.stdout.flush() import Sofa.constants
#%% import sys, os, math os.add_dll_directory(os.path.join(os.getcwd(), '..', 'install')) sys.path.append(os.path.join(os.getcwd(), "..", "install")) import visii SAMPLES_PER_PIXEL = 128 WIDTH = 1024 HEIGHT = 1024 NUM_OBJECTS = 90 NUM_LIGHTS = 20 L_DIST = 10 O_DIST = 5 visii.initialize_interactive() # visii.initialize_headless() camera_entity = visii.entity.create( name="my_camera_entity", transform=visii.transform.create("my_camera_transform"), camera=visii.camera.create_perspective_from_fov(name="my_camera", field_of_view=0.785398, aspect=1., near=.1)) visii.set_camera_entity(camera_entity) camera_entity.get_transform().set_position(0, 0.0, -5.) camera_entity.get_camera().use_perspective_from_fov(0.785398, 1.0, .01) camera_entity.get_camera().set_view( visii.lookAt(
# __init__ for osgeo package. # making the osgeo package version the same as the gdal version: from sys import platform, version_info if version_info >= (3, 8, 0) and platform == 'win32': import os if 'USE_PATH_FOR_GDAL_PYTHON' in os.environ and 'PATH' in os.environ: for p in os.environ['PATH'].split(';'): if p: try: os.add_dll_directory(p) except (FileNotFoundError, OSError): continue def swig_import_helper(): import importlib from os.path import dirname, basename mname = basename(dirname(__file__)) + '._gdal' try: return importlib.import_module(mname) except ImportError: if version_info >= (3, 8, 0) and platform == 'win32': import os if not 'USE_PATH_FOR_GDAL_PYTHON' in os.environ: msg = 'On Windows, with Python >= 3.8, DLLs are no longer imported from the PATH.\n' msg += 'If gdalXXX.dll is in the PATH, then set the USE_PATH_FOR_GDAL_PYTHON=YES environment variable\n' msg += 'to feed the PATH into os.add_dll_directory().' import sys import traceback
#This is a fix for python3.8 #The dll search path has to be manually added import os try: os.add_dll_directory(os.path.join(os.path.dirname(__file__), '..', '..', '..', 'bin')) except: pass
# Linux only os.listxattr("path") # $ getAPathArgument="path" os.listxattr(path="path") # $ getAPathArgument="path" # Linux only os.removexattr("path", "attribute") # $ getAPathArgument="path" os.removexattr(path="path", attribute="attribute") # $ getAPathArgument="path" # Linux only os.setxattr("path", "attribute", "value") # $ getAPathArgument="path" os.setxattr(path="path", attribute="attribute", value="value") # $ getAPathArgument="path" # Windows only os.add_dll_directory("path") # $ getAPathArgument="path" os.add_dll_directory(path="path") # $ getAPathArgument="path" # for `os.exec*`, `os.spawn*`, and `os.posix_spawn*` functions, see the # `SystemCommandExecution.py` file. # Windows only os.startfile("path") # $ getAPathArgument="path" os.startfile(path="path") # $ getAPathArgument="path" # ------------------------------------------------------------------------------ # tempfile # ------------------------------------------------------------------------------ # _mkstemp_inner does `_os.path.join(dir, pre + name + suf)`
import json import logging import os import socket import subprocess import sys import tempfile import time import threading LOGGER = logging.getLogger('ycmd') ROOT_DIR = os.path.normpath(os.path.join(os.path.dirname(__file__), '..')) DIR_OF_THIRD_PARTY = os.path.join(ROOT_DIR, 'third_party') LIBCLANG_DIR = os.path.join(DIR_OF_THIRD_PARTY, 'clang', 'lib') if hasattr(os, 'add_dll_directory'): os.add_dll_directory(LIBCLANG_DIR) from collections.abc import Mapping from urllib.parse import urljoin, urlparse, unquote, quote # noqa from urllib.request import pathname2url, url2pathname # noqa # We replace the re module with regex as it has better support for characters # on multiple code points. However, this module has a compiled component so we # can't import it in YCM if it is built for a different version of Python. We # fall back to the re module in that case. try: import regex as re except ImportError: # pragma: no cover import re # noqa # Creation flag to disable creating a console window on Windows. See
# # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import os, sys, platform if sys.version_info >= (3, 8, 0) and platform.system() == "Windows": for path in [x.strip() for x in os.environ['PATH'].split(';') if x]: os.add_dll_directory(path) import opengeode_py_geometry as geom if __name__ == '__main__': box = geom.BoundingBox2D() box.add_point(geom.Point2D([-1, -1])) box.add_point(geom.Point2D([1, 1])) box2 = box box2.add_point(geom.Point2D([-2, -2])) box2.add_point(geom.Point2D([0, 0])) box2.add_box(box) if box2.min() != geom.Point2D([-2, -2]): raise ValueError("[Test] Error in BoundingBox union computation")
if lib_path is None: raise ModuleNotFoundError("{} was not found in {}".format(lib_name, search_paths)) if os.path.getsize(lib_path) < 1000: raise ModuleNotFoundError("{} is too small. Did you forget to init git lfs? Try this:\n" " 1. Install git lfs (https://git-lfs.github.com/)\n" " 2. Run `cd {}`\n" " 3. Run `git lfs install`\n" " 4. Run `git lfs pull`".format(lib_path, os.path.dirname(lib_path))) if os.name == 'nt': dll_dir = os.path.dirname(lib_path) try: # New way in python 3.8+ os.add_dll_directory(dll_dir) except: os.environ['PATH'] = dll_dir + os.pathsep + os.environ['PATH'] lib = windll.LoadLibrary(lib_path) else: lib = cdll.LoadLibrary(lib_path) # libfibre definitions --------------------------------------------------------# PostSignature = CFUNCTYPE(c_int, CFUNCTYPE(None, c_void_p), POINTER(c_int)) RegisterEventSignature = CFUNCTYPE(c_int, c_int, c_uint32, CFUNCTYPE(None, c_void_p, c_int), POINTER(c_int)) DeregisterEventSignature = CFUNCTYPE(c_int, c_int) CallLaterSignature = CFUNCTYPE(c_void_p, c_float, CFUNCTYPE(None, c_void_p), POINTER(c_int)) CancelTimerSignature = CFUNCTYPE(c_int, c_void_p) OnFoundObjectSignature = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p)