def write_full(self, key, data): """ Write an entire object synchronously. The object is filled with the provided data. If the object exists, it is atomically truncated and then written. :param key: name of the object :type key: str :param data: data to write :type data: str :raises: :class:`TypeError` :raises: :class:`Error` :returns: int - 0 on success """ self.require_ioctx_open() if not isinstance(key, str): raise TypeError('key must be a string') if not isinstance(data, str): raise TypeError('data must be a string') length = len(data) ret = self.librados.rados_write_full(self.io, c_char_p(key), c_char_p(data), c_size_t(length)) if ret == 0: return ret else: raise make_ex(ret, "Ioctx.write(%s): failed to write_full %s" % \ (self.name, key))
def convert_word(self, word, flat=False): if word[-1] == ':': word = word[0:-1] if not word: return list() if word[0] == '-': word = word[1:] self.lock.acquire() we = word.encode('utf-8') st = ctypes.c_char_p(we) self.lib.analyse_item(st, 0) result = self.lib.first_analysis_result() ret = [] while result: if self.lib.get_value_type(result) != 4: raise Exception('Unknown libmalaga result type!') s = ctypes.c_char_p(self.lib.get_value_string(result)) ret.append(str(s.value, 'utf-8')) self.libc.free(s) result = self.lib.next_analysis_result() self.lock.release() if flat: ret = list(set(ret)) if len(ret) > 0: trans = self.FI_TRANSFORMS.get(ret[0]) if trans and ret == trans[0]: ret = trans[1] else: if len(ret) == 1: ret = ret[0] return ret
def rename(self, src, dst): self.require_state("mounted") if not isinstance(src, basestring) or not isinstance(dst, basestring): raise TypeError('source and destination must be a string') ret = self.libcephfs.ceph_rename(self.cluster, c_char_p(src), c_char_p(dst)) if ret < 0: raise make_ex(ret, "error in rename '%s' to '%s'" % (src, dst))
def multi_graph(V): for i, a in enumerate(F): for j, b in enumerate(F): if i == j: continue t = c_sp_align(c_char_p(a), c_char_p(b)) yield (i, j, t)
def mds_command(self, mds_spec, args, input_data): """ :return 3-tuple of output status int, output status string, output data """ cmdarr = (c_char_p * len(args))(*args) outbufp = pointer(pointer(c_char())) outbuflen = c_long() outsp = pointer(pointer(c_char())) outslen = c_long() ret = self.libcephfs.ceph_mds_command(self.cluster, c_char_p(mds_spec), cmdarr, len(args), c_char_p(input_data), len(input_data), outbufp, byref(outbuflen), outsp, byref(outslen)) my_outbuf = outbufp.contents[:(outbuflen.value)] my_outs = outsp.contents[:(outslen.value)] if outbuflen.value: self.libcephfs.ceph_buffer_free(outbufp.contents) if outslen.value: self.libcephfs.ceph_buffer_free(outsp.contents) return (ret, my_outbuf, my_outs)
def get_consensus(align, quals=[], cons_thres=-1.0, qual_thres=' ', gapped=False): cons_thres_c = ctypes.c_double(cons_thres) qual_thres_c = ctypes.c_char(qual_thres) n_seqs = len(align) if gapped: gapped_c = 1 else: gapped_c = 0 assert not quals or len(quals) == n_seqs, 'Different number of sequences and quals.' seq_len = None for seq in (align + quals): if seq_len is None: seq_len = len(seq) else: assert seq_len == len(seq), 'All sequences in the alignment must be the same length.' align_c = (ctypes.c_char_p * n_seqs)() for i, seq in enumerate(align): align_c[i] = ctypes.c_char_p(seq) quals_c = (ctypes.c_char_p * n_seqs)() for i, qual in enumerate(quals): quals_c[i] = ctypes.c_char_p(qual) if not quals: quals_c = 0 return consensus.get_consensus(align_c, quals_c, n_seqs, seq_len, cons_thres_c, qual_thres_c, gapped_c)
def get_consensus_duplex(align1, align2, quals1=[], quals2=[], cons_thres=-1.0, qual_thres=' ', method='iupac'): assert method in ('iupac', 'freq') cons_thres_c = ctypes.c_double(cons_thres) qual_thres_c = ctypes.c_char(qual_thres) n_seqs1 = len(align1) n_seqs2 = len(align2) assert (not quals1 and not quals2) or (quals1 and quals2) assert not quals1 or len(quals1) == n_seqs1 assert not quals2 or len(quals2) == n_seqs2 seq_len = None for seq in (align1 + align2 + quals1 + quals2): if seq_len is None: seq_len = len(seq) else: assert seq_len == len(seq), 'All sequences in the alignment must be the same length.' align1_c = (ctypes.c_char_p * n_seqs1)() for i, seq in enumerate(align1): align1_c[i] = ctypes.c_char_p(seq) align2_c = (ctypes.c_char_p * n_seqs1)() for i, seq in enumerate(align2): align2_c[i] = ctypes.c_char_p(seq) quals1_c = (ctypes.c_char_p * n_seqs1)() for i, seq in enumerate(quals1): quals1_c[i] = ctypes.c_char_p(seq) quals2_c = (ctypes.c_char_p * n_seqs1)() for i, seq in enumerate(quals2): quals2_c[i] = ctypes.c_char_p(seq) if not quals1: quals1_c = 0 if not quals2: quals2_c = 0 return consensus.get_consensus_duplex(align1_c, align2_c, quals1_c, quals2_c, n_seqs1, n_seqs2, seq_len, cons_thres_c, qual_thres_c, method)
def move_container(ns_name, cid): print "Moving container " + cid + " to another meta2" ns_name = ctypes.c_char_p(ns_name) cid = ctypes.c_char_p(cid) lib = ctypes.cdll.LoadLibrary("librulesmotorpy2c.so") rc = lib.motor_move_container(ns_name, cid) return bool(rc)
def create_yamr(self, stor_file, port, info_filename, n_fail_max, overdue_resched_fac, overdue_giveup_fac): func = self.runlib.rmic_create_yamr func.restype = ctypes.c_void_p self.obj = func( ctypes.c_char_p(stor_file), ctypes.c_char_p(port), ctypes.c_char_p(info_filename), n_fail_max, ctypes.c_double(overdue_resched_fac), ctypes.c_double(overdue_giveup_fac))
def connect(self): databroker = self._databroker if self._conn is None: conn = databroker.create_connection() self._conn = conn eptTCP = dbrksvrtype.TProtocolType.eptTCP.value emtVideo = dbrksvrtype.TMediaType.emtVideo.value emtAudio = dbrksvrtype.TMediaType.emtAudio.value conn_opt = dbrkhelper.TDataBrokerConnectionOptions() conn_opt.pzIPAddr = ctypes.c_char_p(self._camera.url) conn_opt.wHttpPort = ctypes.c_ushort(self._camera.http_port) conn_opt.pzUID = ctypes.c_char_p(self._camera.username) conn_opt.pzPWD = ctypes.c_char_p(self._camera.password) conn_opt.dwProtocolType = eptTCP conn_opt.pzServerType = "auto" conn_opt.dwMediaType = (emtVideo | emtAudio) conn_opt.pfStatus = dbrkhelper.FTDataBrokerStatusCallback(self._update_connection_status) conn_opt.pfAV = dbrkhelper.FTDataBrokerAVCallback(self._put_one_frame) dwFlags = dbrkhelper.TDataBrokerConnOptionFlag.eConOptProtocolAndMediaType.value dwFlags |= dbrkhelper.TDataBrokerConnOptionFlag.eConOptHttpPort.value conn_opt.dwFlags = ctypes.c_ulong(dwFlags) databroker.set_connection_options(conn, conn_opt) else: conn = self._conn return databroker.connect(conn)
def exists(name): """Validates the name of a netgroup""" try: ## try to switch to 'str' object rather than unicode name = name.encode('utf8') except Exception as ex: ## ignore pass host,user,domain = c_char_p(None),c_char_p(None),c_char_p(None) libc = CDLL('libc.so.6') libc.setnetgrent(name) try: while libc.getnetgrent(_byref(host), _byref(user), _byref(domain)): libc.endnetgrent() return True libc.endnetgrent() return False except Exception as ex: libc.endnetgrent() return False
def aead_decrypt(self, data): """ Decrypt data and authenticate tag :param data: cipher text with tag :return: plain text """ global buf_size, buf cipher_out_len = c_size_t(0) plen = len(data) - self._tlen if buf_size < plen: buf_size = plen * 2 buf = create_string_buffer(buf_size) tag = data[plen:] r = libmbedtls.mbedtls_cipher_auth_decrypt( byref(self._ctx), c_char_p(self._nonce.raw), c_size_t(self._nlen), None, c_size_t(0), c_char_p(data), c_size_t(plen), byref(buf), byref(cipher_out_len), c_char_p(tag), c_size_t(self._tlen) ) if r: raise Exception('AEAD encrypt failed {0:#x}'.format(r)) self.cipher_ctx_init() return buf.raw[:cipher_out_len.value]
def __init__(self, cipher_name, key, iv, op, crypto_path=None): if cipher_name[:len('mbedtls:')] == 'mbedtls:': cipher_name = cipher_name[len('mbedtls:'):] MbedTLSCryptoBase.__init__(self, cipher_name, crypto_path) key_ptr = c_char_p(key) iv_ptr = c_char_p(iv) r = libmbedtls.mbedtls_cipher_setkey( byref(self._ctx), key_ptr, c_int(len(key) * 8), c_int(op) ) if r: self.clean() raise Exception('can not set cipher key') r = libmbedtls.mbedtls_cipher_set_iv( byref(self._ctx), iv_ptr, c_size_t(len(iv)) ) if r: self.clean() raise Exception('can not set cipher iv') r = libmbedtls.mbedtls_cipher_reset(byref(self._ctx)) if r: self.clean() raise Exception('can not reset cipher') self.encrypt = self.update self.decrypt = self.update
def mount(self, source=None, target=None, mount_type=None, filesystemtype=None, data=None): if not [arg for arg in [source, target, filesystemtype, mount_type] if arg is not None]: return func_obj = self.functions["mount"] if source is None: source = "none" if target is None: target = c_char_p() if filesystemtype is None: filesystemtype = c_char_p() if mount_type is None: mount_type = "unchanged" if data is None: data = c_void_p() flag = func_obj.extra["flag"] propagation = func_obj.extra["propagation"] mount_flags = propagation[mount_type] mount_vals = [flag[k] for k in mount_flags] flags = reduce(lambda res, val: res | val, mount_vals, 0) self._c_func_mount(source, target, filesystemtype, flags, data)
def aead_encrypt(self, data): """ Encrypt data with authenticate tag :param data: plain text :return: cipher text with tag """ global buf_size, buf plen = len(data) if buf_size < plen + self._tlen: buf_size = (plen + self._tlen) * 2 buf = create_string_buffer(buf_size) cipher_out_len = c_size_t(0) tag_buf = create_string_buffer(self._tlen) r = libmbedtls.mbedtls_cipher_auth_encrypt( byref(self._ctx), c_char_p(self._nonce.raw), c_size_t(self._nlen), None, c_size_t(0), c_char_p(data), c_size_t(plen), byref(buf), byref(cipher_out_len), byref(tag_buf), c_size_t(self._tlen) ) assert cipher_out_len.value == plen if r: raise Exception('AEAD encrypt failed {0:#x}'.format(r)) self.cipher_ctx_init() return buf.raw[:cipher_out_len.value] + tag_buf.raw[:self._tlen]
def getBoxFilter(self, time, point_coords, data_set = 'isotropic1024coarse', make_modulo = False, field = 'velocity', filter_width = 7*2*np.pi / 1024): if not self.connection_on: print('you didn\'t connect to the database') sys.exit() if not (point_coords.shape[-1] == 3): print ('wrong number of values for coordinates in getBoxFilter') sys.exit() return None if not (point_coords.dtype == np.float32): print 'point coordinates in getBoxFilter must be floats. stopping.' sys.exit() return None npoints = point_coords.shape[0] for i in range(1, len(point_coords.shape)-1): npoints *= point_coords.shape[i] if make_modulo: pcoords = np.zeros(point_coords.shape, np.float64) pcoords[:] = point_coords np.mod(pcoords, 2*np.pi, point_coords) result_array = point_coords.copy() self.lib.getBoxFilter(self.authToken, ctypes.c_char_p(data_set), ctypes.c_char_p(field), ctypes.c_float(time), ctypes.c_float(filter_width), ctypes.c_int(npoints), point_coords.ctypes.data_as(ctypes.POINTER(ctypes.POINTER(ctypes.c_float))), result_array.ctypes.data_as(ctypes.POINTER(ctypes.POINTER(ctypes.c_float)))) return result_array
def SetValue(self, value): # set object type otype = None size = 8 if type(value) == str: otype = ASN_OCTET_STR size = len(value) value = ctypes.c_char_p(value) elif type(value) == int: otype = ASN_INTEGER value = ctypes.pointer(ctypes.c_int(value)) elif type(value) == float: otype = ASN_APP_FLOAT value = ctypes.pointer(ctypes.c_float(value)) elif type(value) == SnmpIpAddress: otype = ASN_IPADDRESS size = 4 value = ctypes.c_char_p(socket.inet_aton(value)) elif type(value) == SnmpCounter32: otype = ASN_COUNTER32 value = ctypes.pointer(ctypes.c_uint(value)) elif type(value) == SnmpGauge32: otype = ASN_UNSIGNED value = ctypes.pointer(ctypes.c_uint(value)) axl.snmp_set_var_typed_value(self.__request.requestvb, otype, ctypes.cast(value, ctypes.POINTER(ctypes.c_ubyte)), size) self.value = value
def vasco_verify(data, params, password, challenge="\0" * 16): res = Vasco_DLL.AAL2VerifyPassword(pointer(data), pointer(params), c_char_p(password), c_char_p(challenge) ) return (res, data)
def ENopen(self, inpfile=None, rptfile=None, binfile=None): """ Opens EPANET input file & reads in network data Arguments: * inpfile = EPANET .inp input file (default to constructor value) * rptfile = Output file to create (default to constructor value) * binfile = Binary output file to create (default to constructor value) """ if self.fileLoaded: self.ENclose() if self.fileLoaded: raise(EPANETException('Fatal error closing previously opened file')) if inpfile is None: inpfile = self.inpfile if rptfile is None: rptfile = self.rptfile if binfile is None: binfile = self.binfile en_open = getattr(self.ENlib, 'ENopen') self.errcode = en_open(c_char_p(inpfile.encode()), c_char_p(rptfile.encode()), c_char_p(binfile.encode())) self._error() if self.errcode < 100: self.fileLoaded = True return
def vasco_dpxinit(filename="demovdp.dpx", transportkey=None): ''' This function returns - error code - filehandle (TDPXHandle) - application count - application names - token counts ''' if not transportkey: transportkey = "1" * 32 c_filename = c_char_p(filename) c_transportkey = c_char_p(transportkey) # string with 97 bytes appl_names = "." * 97 p_names = c_char_p(appl_names) fh = TDPXHandle() p_fh = pointer(fh) appl_count = c_int(0) p_acount = pointer(appl_count) token_count = c_int(0) p_tcount = pointer(token_count) res = Vasco_DLL.AAL2DPXInit(p_fh, c_filename, c_transportkey, p_acount, p_names, p_tcount) return (res, fh, appl_count, appl_names, token_count)
def vasco_genpassword(data, params, challenge="\0" * 16): password = "******" * 41 res = Vasco_DLL.AAL2GenPassword(pointer(data), pointer(params), c_char_p(password), c_char_p(challenge)) return (res, password)
def _sem_open(name, value=None): """ Construct or retrieve a semaphore with the given name If value is None, try to retrieve an existing named semaphore. Else create a new semaphore with the given value """ if value is None: handle = pthread.sem_open(ctypes.c_char_p(name), 0) else: handle = pthread.sem_open(ctypes.c_char_p(name), SEM_OFLAG, SEM_PERM, ctypes.c_int(value)) if handle == SEM_FAILURE: e = ctypes.get_errno() if e == errno.EEXIST: raise FileExistsError("a semaphore named %s already exists" % name) elif e == errno.ENOENT: raise FileNotFoundError('cannot find semaphore named %s' % name) elif e == errno.ENOSYS: raise NotImplementedError('No semaphore implementation on this ' 'system') else: raiseFromErrno() return handle
def _commoncrypto_pbkdf2(data, salt, iterations, digest, keylen): """Common Crypto compatibile wrapper """ c_hashfunc = ctypes.c_uint32(_commoncrypto_hashlib_to_crypto_map_get(digest)) c_pass = ctypes.c_char_p(data) c_passlen = ctypes.c_size_t(len(data)) c_salt = ctypes.c_char_p(salt) c_saltlen = ctypes.c_size_t(len(salt)) c_iter = ctypes.c_uint(iterations) c_keylen = ctypes.c_size_t(keylen) c_buff = ctypes.create_string_buffer(keylen) crypto.CCKeyDerivationPBKDF.restype = ctypes.c_int crypto.CCKeyDerivationPBKDF.argtypes = [ctypes.c_uint32, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_uint32, ctypes.c_uint, ctypes.c_char_p, ctypes.c_size_t] ret = crypto.CCKeyDerivationPBKDF(2, # hardcoded 2-> PBKDF2 c_pass, c_passlen, c_salt, c_saltlen, c_hashfunc, c_iter, c_buff, c_keylen) return (1 - ret, c_buff)
def setFrom(self, val, name=None): """Create an argument using a value as input. Arguments: Value -- an OpenSCAD value string -- the name of the value """ if name: self.name = ctypes.c_char_p(name) else: self.name = ctypes.c_char_p(0) if isinstance(val, bool): self.type = 'b' self.boolValue = ctypes.c_bool(val) elif isinstance(val, int) or isinstance(val, float): self.type = 'd' self.dblValue = ctypes.c_double(val) elif isinstance(val, str): self.type = 's' self.strValue = ctypes.c_char_p(val) elif isinstance(val, list) or isinstance(val, tuple): self.type = 'v' self.vecLen = ctypes.c_int(len(val)) arr = (ctypes.c_double * len(val))() for i, v in enumerate(val): arr[i] = ctypes.c_double(v) self.vecValue = arr
def getPeakProperty(self, p_name): """ Return a numpy array containing the requested property. """ if not p_name in self.peak_properties: raise MultiFitterException("No such property '" + p_name + "'") # Properties that are calculated from other properties. if(self.peak_properties[p_name] == "compound"): # Return 0 length array if there are no localizations. if(self.getNFit() == 0): return numpy.zeros(0, dtype = numpy.float64) # Peak significance calculation. if(p_name == "significance"): bg_sum = self.getPeakProperty("bg_sum") fg_sum = self.getPeakProperty("fg_sum") return fg_sum/numpy.sqrt(bg_sum) # Floating point properties. elif(self.peak_properties[p_name] == "float"): values = numpy.ascontiguousarray(numpy.zeros(self.getNFit(), dtype = numpy.float64)) self.clib.mFitGetPeakPropertyDouble(self.mfit, values, ctypes.c_char_p(p_name.encode())) return values # Integer properties. elif(self.peak_properties[p_name] == "int"): values = numpy.ascontiguousarray(numpy.zeros(self.getNFit(), dtype = numpy.int32)) self.clib.mFitGetPeakPropertyInt(self.mfit, values, ctypes.c_char_p(p_name.encode())) return values
def __init__(self, geom_input, srs=None): "Initializes Geometry on either WKT or an OGR pointer as input." str_instance = isinstance(geom_input, basestring) # If HEX, unpack input to to a binary buffer. if str_instance and hex_regex.match(geom_input): geom_input = buffer(a2b_hex(geom_input.upper())) str_instance = False # Constructing the geometry, if str_instance: # Checking if unicode if isinstance(geom_input, unicode): # Encoding to ASCII, WKT or HEX doesn't need any more. geom_input = geom_input.encode('ascii') wkt_m = wkt_regex.match(geom_input) json_m = json_regex.match(geom_input) if wkt_m: if wkt_m.group('type').upper() == 'LINEARRING': # OGR_G_CreateFromWkt doesn't work with LINEARRING WKT. # See http://trac.osgeo.org/gdal/ticket/1992. g = capi.create_geom(OGRGeomType(wkt_m.group('type')).num) capi.import_wkt(g, byref(c_char_p(geom_input))) else: g = capi.from_wkt(byref(c_char_p(geom_input)), None, byref(c_void_p())) elif json_m: if GEOJSON: g = capi.from_json(geom_input) else: raise NotImplementedError('GeoJSON input only supported on GDAL 1.5+.') else: # Seeing if the input is a valid short-hand string # (e.g., 'Point', 'POLYGON'). ogr_t = OGRGeomType(geom_input) g = capi.create_geom(OGRGeomType(geom_input).num) elif isinstance(geom_input, buffer): # WKB was passed in g = capi.from_wkb(str(geom_input), None, byref(c_void_p()), len(geom_input)) elif isinstance(geom_input, OGRGeomType): # OGRGeomType was passed in, an empty geometry will be created. g = capi.create_geom(geom_input.num) elif isinstance(geom_input, self.ptr_type): # OGR pointer (c_void_p) was the input. g = geom_input else: raise OGRException('Invalid input type for OGR Geometry construction: %s' % type(geom_input)) # Now checking the Geometry pointer before finishing initialization # by setting the pointer for the object. if not g: raise OGRException('Cannot create OGR Geometry from input: %s' % str(geom_input)) self.ptr = g # Assigning the SpatialReference object to the geometry, if valid. if bool(srs): self.srs = srs # Setting the class depending upon the OGR Geometry Type self.__class__ = GEO_CLASSES[self.geom_type.num]
def set_param(self, name, value): """set paramter to the trainer""" name = str(name) value = str(value) cxnlib.CXNNetSetParam(self.handle, ctypes.c_char_p(name.encode('utf-8')), ctypes.c_char_p(value.encode('utf-8')))
def _openssl_pbkdf2(data, salt, iterations, digest, keylen): """OpenSSL compatibile wrapper """ c_hashfunc = ctypes.c_void_p(_openssl_hashlib_to_crypto_map_get(digest)) c_pass = ctypes.c_char_p(data) c_passlen = ctypes.c_int(len(data)) c_salt = ctypes.c_char_p(salt) c_saltlen = ctypes.c_int(len(salt)) c_iter = ctypes.c_int(iterations) c_keylen = ctypes.c_int(keylen) c_buff = ctypes.create_string_buffer(keylen) # PKCS5_PBKDF2_HMAC(const char *pass, int passlen, # const unsigned char *salt, int saltlen, int iter, # const EVP_MD *digest, # int keylen, unsigned char *out); crypto.PKCS5_PBKDF2_HMAC.argtypes = [ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_int, ctypes.c_void_p, ctypes.c_int, ctypes.c_char_p] crypto.PKCS5_PBKDF2_HMAC.restype = ctypes.c_int err = crypto.PKCS5_PBKDF2_HMAC(c_pass, c_passlen, c_salt, c_saltlen, c_iter, c_hashfunc, c_keylen, c_buff) return (err, c_buff)
def __init__(self, packet, layers=0): fields = struct.unpack("!HHIIBBHHH", packet[:self.tcp_min_header_size]) self.src_port = fields[0] self.dst_port = fields[1] self.seqnum = fields[2] self.acknum = fields[3] self.data_offset = 4 * (fields[4] >> 4) self.urg = fields[5] & 32 self.ack = fields[5] & 16 self.psh = fields[5] & 8 self.rst = fields[5] & 4 self.syn = fields[5] & 2 self.fin = fields[5] & 1 self.win = fields[6] self.sum = fields[7] urg_offset = 4 * fields[8] # rarely used if self.data_offset < 20: self.opt = b'' self.payload = b'' else: self.opt = ctypes.c_char_p(binascii.hexlify(packet[20:self.data_offset])) self.payload = ctypes.c_char_p(binascii.hexlify(packet[self.data_offset:]))
def defineVariable(self, name='', value=''): """used to bind mailmerge variable to a recipient. name: string for mailmerge variable's name value: string for mailmerge variable's value""" if not pmta.PmtaRcptDefineVariable(self.recipient, c_char_p(name), c_char_p(value)): raise PmtaRecipientError(self.recipient)
# os.system('open ' + test_name + '.html') if __name__ == "__main__": if len(sys.argv) == 2 and str(sys.argv[1]) != "docker": run_test(str(sys.argv[1])) else: exe_ver = '???' lib_ver = '???' response = subprocess.check_output([CAPTION_INSPECTOR_EXE, '-v'], stderr=subprocess.STDOUT) if response.split()[0] == b"Version:": exe_ver = response.strip().decode('utf-8') clib = ctypes.CDLL(CAPTION_INSPECTOR_LIBRARY) clib.ExtrnlAdptrGetVersion.restype = ctypes.c_char_p response = clib.ExtrnlAdptrGetVersion() lib_ver = ctypes.c_char_p(response).value.decode('utf-8') if exe_ver != lib_ver: print("Version Mismatch! " + exe_ver + " vs. " + lib_ver) exit(1) date_str = str(datetime.now().strftime('%Y_%m_%d__%H_%M_%S')) out_file_name = date_str + '_test_output' file = open(out_file_name + '.xml', "w") file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") file.write("<testsuites name=\"Caption Inspector " + exe_ver + " Tests\">\n") file.close() retval = 0 for test in py_test_suites: if os.system('pytest -o junit_suite_name="' + py_test_suites_names[test] + '" --junitxml ' + date_str + '_' + test + '.xml test__' + test + '.py') != 0 or retval != 0: retval = 1 os.system('cat ' + date_str + '_' + test + '.xml >> ' + out_file_name + '.xml') # os.system('rm ' + date_str + '_' + test + '.xml')
def create_surface(self, x=0, y=0, w=0, h=0, layer=0): #Set the viewport position and size dst_rect = c_ints((x, y, w, h)) src_rect = c_ints((x, y, w << 16, h << 16)) if PLATFORM == PLATFORM_ANDROID: self.surface = openegl.eglGetCurrentSurface(EGL_DRAW) # Get the width and height of the screen - TODO, this system returns 100x100 time.sleep(0.2) #give it a chance to find out the dimensions w = c_int() h = c_int() openegl.eglQuerySurface(self.display, self.surface, EGL_WIDTH, byref(w)) openegl.eglQuerySurface(self.display, self.surface, EGL_HEIGHT, byref(h)) self.width, self.height = w.value, h.value elif PLATFORM == PLATFORM_PI: self.dispman_display = bcm.vc_dispmanx_display_open( 0) #LCD setting self.dispman_update = bcm.vc_dispmanx_update_start(0) alpha = c_ints((DISPMANX_FLAGS_ALPHA_PREMULT, 0, 0)) self.dispman_element = bcm.vc_dispmanx_element_add( self.dispman_update, self.dispman_display, layer, dst_rect, 0, src_rect, DISPMANX_PROTECTION_NONE, alpha, 0, 0) nativewindow = (GLint * 3)(self.dispman_element, w, h + 1) bcm.vc_dispmanx_update_submit_sync(self.dispman_update) self.nw_p = ctypes.pointer(nativewindow) ### NB changing the argtypes to allow passing of bcm native window is ### deeply unsatisfactory. But xlib defines Window as c_ulong and ctypes ### isn't happy about a pointer being cast to an int openegl.eglCreateWindowSurface.argtypes = [ EGLDisplay, EGLConfig, POINTER((GLint * 3)), EGLint ] self.surface = openegl.eglCreateWindowSurface( self.display, self.config, self.nw_p, 0) elif pi3d.USE_PYGAME: import pygame flags = pygame.OPENGL wsize = (w, h) if w == self.width and h == self.height: # i.e. full screen flags = pygame.FULLSCREEN | pygame.OPENGL wsize = (0, 0) if self.display_config & DISPLAY_CONFIG_NO_RESIZE: flags |= pygame.RESIZABLE if self.display_config & DISPLAY_CONFIG_NO_FRAME: flags |= pygame.NOFRAME if self.display_config & DISPLAY_CONFIG_FULLSCREEN: flags |= pygame.FULLSCREEN elif self.display_config & DISPLAY_CONFIG_MAXIMIZED: flags |= pygame.FULLSCREEN wsize = (0, 0) self.width, self.height = w, h self.d = pygame.display.set_mode(wsize, flags) self.window = pygame.display.get_wm_info()["window"] self.surface = openegl.eglCreateWindowSurface( self.display, self.config, self.window, 0) else: # work on basis it's X11 # Set some WM info self.root = xlib.XRootWindowOfScreen(self.screen) if self.use_glx: # For drawing on X window with transparent background numfbconfigs = c_int() VisData = c_ints( (glx.GLX_RENDER_TYPE, glx.GLX_RGBA_BIT, glx.GLX_DRAWABLE_TYPE, glx.GLX_WINDOW_BIT, glx.GLX_DOUBLEBUFFER, True, glx.GLX_RED_SIZE, 8, glx.GLX_GREEN_SIZE, 8, glx.GLX_BLUE_SIZE, 8, glx.GLX_ALPHA_SIZE, 8, glx.GLX_DEPTH_SIZE, 16, 0)) glx_screen = xlib.XDefaultScreen(self.d) fbconfigs = glx.glXChooseFBConfig(self.d, glx_screen, VisData, byref(numfbconfigs)) fbconfig = 0 for i in range(numfbconfigs.value): visual = glx.glXGetVisualFromFBConfig( self.d, fbconfigs[i]).contents if not visual: continue pict_format = glx.XRenderFindVisualFormat( self.d, visual.visual).contents if not pict_format: continue fbconfig = fbconfigs[i] if pict_format.direct.alphaMask > 0: break if not fbconfig: print("No matching FB config found") #/* Create a colormap - only needed on some X clients, eg. IRIX */ cmap = xlib.XCreateColormap(self.d, self.root, visual.visual, AllocNone) attr = xlib.XSetWindowAttributes() attr.colormap = cmap attr.background_pixmap = 0 attr.border_pixmap = 0 attr.border_pixel = 0 attr.event_mask = (StructureNotifyMask | EnterWindowMask | LeaveWindowMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | OwnerGrabButtonMask | KeyPressMask | KeyReleaseMask) attr_mask = ( # CWBackPixmap| CWColormap | CWBorderPixel | CWEventMask) self.window = xlib.XCreateWindow(self.d, self.root, x, y, w, h, 0, visual.depth, 1, visual.visual, attr_mask, byref(attr)) else: # normal EGL created context self.window = xlib.XCreateSimpleWindow(self.d, self.root, x, y, w, h, 1, 0, 0) s = ctypes.create_string_buffer(b'WM_DELETE_WINDOW') self.WM_DELETE_WINDOW = ctypes.c_ulong( xlib.XInternAtom(self.d, s, 0)) # set window title title = ctypes.c_char_p(self.window_title) title_length = ctypes.c_int(len(self.window_title)) wm_name_atom = ctypes.c_ulong( xlib.XInternAtom(self.d, ctypes.create_string_buffer(b'WM_NAME'), 0)) string_atom = ctypes.c_ulong( xlib.XInternAtom(self.d, ctypes.create_string_buffer(b'STRING'), 0)) xlib.XChangeProperty(self.d, self.window, wm_name_atom, string_atom, 8, xlib.PropModeReplace, title, title_length) if (w == self.width and h == self.height) or (self.display_config & DISPLAY_CONFIG_FULLSCREEN): # set full-screen. Messy c function calls! wm_state = ctypes.c_ulong( xlib.XInternAtom(self.d, b'_NET_WM_STATE', 0)) fullscreen = ctypes.c_ulong( xlib.XInternAtom(self.d, b'_NET_WM_STATE_FULLSCREEN', 0)) fullscreen = ctypes.cast(ctypes.pointer(fullscreen), ctypes.c_char_p) XA_ATOM = 4 xlib.XChangeProperty(self.d, self.window, wm_state, XA_ATOM, 32, xlib.PropModeReplace, fullscreen, 1) self.width, self.height = w, h if self.display_config & DISPLAY_CONFIG_HIDE_CURSOR: black = xlib.XColor() black.red = 0 black.green = 0 black.blue = 0 noData = ctypes.c_char_p(bytes([0, 0, 0, 0, 0, 0, 0, 0])) bitmapNoData = xlib.XCreateBitmapFromData( self.d, self.window, noData, 8, 8) invisibleCursor = xlib.XCreatePixmapCursor( self.d, bitmapNoData, bitmapNoData, black, black, 0, 0) xlib.XDefineCursor(self.d, self.window, invisibleCursor) #TODO add functions to xlib for these window manager libx11 functions #self.window.set_wm_name('pi3d xlib window') #self.window.set_wm_icon_name('pi3d') #self.window.set_wm_class('draw', 'XlibExample') xlib.XSetWMProtocols(self.d, self.window, self.WM_DELETE_WINDOW, 1) #self.window.set_wm_hints(flags = Xutil.StateHint, # initial_state = Xutil.NormalState) #self.window.set_wm_normal_hints(flags = (Xutil.PPosition | Xutil.PSize # | Xutil.PMinSize), # min_width = 20, # min_height = 20) xlib.XSelectInput(self.d, self.window, KeyPressMask | KeyReleaseMask) xlib.XMapWindow(self.d, self.window) #xlib.XMoveWindow(self.d, self.window, x, y) #TODO this has to happen later. Works after rendering first frame. Check when if self.use_glx: dummy = c_int() if not glx.glXQueryExtension(self.d, byref(dummy), byref(dummy)): print("OpenGL not supported by X server\n") dummy_glx_context = ctypes.cast(0, glx.GLXContext) self.render_context = glx.glXCreateNewContext( self.d, fbconfig, glx.GLX_RGBA_TYPE, dummy_glx_context, True) if not self.render_context: print("Failed to create a GL context\n") if not glx.glXMakeContextCurrent( self.d, self.window, self.window, self.render_context): print("glXMakeCurrent failed for window\n") else: self.surface = openegl.eglCreateWindowSurface( self.display, self.config, self.window, 0) if not self.use_glx: assert self.surface != EGL_NO_SURFACE and self.surface is not None r = openegl.eglMakeCurrent(self.display, self.surface, self.surface, self.context) assert r #Create viewport opengles.glViewport(GLint(0), GLint(0), GLsizei(w), GLsizei(h))
def set_pyverdict(queue_handle, packet_id, verdict, buffer_len, buffer): set_verdict(queue_handle, packet_id, verdict, buffer_len, ctypes.c_char_p(buffer))
def genConnectivitySig(self, tdiCsvFile, signatureFileName, fiberFile): if self.CoreModule is None: return res = self.CoreModule.genConnectivitySig(c_char_p(tdiCsvFile), c_char_p(signatureFileName), c_char_p(fiberFile))
def notify_peer_disconnected(self, peer_id): """An existing peer was dropped""" self._notify( "consensus_notifier_notify_peer_disconnected", ctypes.c_char_p(peer_id.encode()))
def notify_peer_connected(self, peer_id): """A new peer was added""" self._notify( "consensus_notifier_notify_peer_connected", ctypes.c_char_p(peer_id.encode()))
def notify_block_invalid(self, block_id): """This block cannot be committed successfully""" self._notify( "consensus_notifier_notify_block_invalid", ctypes.c_char_p(block_id.encode()))
def read_polar(radar_file, moment="ZH", physic_value=False, masked_array=False, verbose=False): """ Reads a METRANET polar data file Parameters ---------- radar_file : str file name moment : str moment name physic_value : boolean If true returns the physical value. Otherwise the digital value masked_array : boolean If true returns a numpy masked array with NaN values masked. Otherwise returns a regular masked array with NaN values verbose : boolean If true prints out extra information Returns ------- ret_data : RadarData object An object containing the information read from the file. None if the file has not been properly read """ c_speed = 299792458 # m/s ret_data = RadarData(moment=moment) prd_header = {} prd_data_level = ret_data.scale # uppercase moment moment = moment.upper() # as big as possible max_bins = 3000 max_azimuths = 500 if verbose: print("Read POLAR file %s " % radar_file) # read BINARY data prdt_size = max_bins * max_azimuths if moment == 'PHI': prdt_size *= 2 prd_data = np.zeros(prdt_size, np.ushort) else: prd_data = np.zeros(prdt_size, np.ubyte) bfile = os.path.basename(radar_file) if (bfile.startswith('MS') or bfile.startswith('MH') or bfile.startswith('ML')): momentms = True Header_stru = Header_struPM else: momentms = False Header_stru = Header_struPM t_pol_header = (Header_stru * max_azimuths)() t_rad_header = (Header_struMS * 1)() metranet_lib = get_library(momentms=momentms, verbose=verbose) ret = metranet_lib.py_decoder_p2( ctypes.c_char_p(radar_file.encode('utf-8')), np.ctypeslib.as_ctypes(prd_data), ctypes.c_int(prdt_size), ctypes.c_char_p(moment.encode('utf-8')), ctypes.byref(t_pol_header), ctypes.byref(t_rad_header), ctypes.c_int(verbose)) if ret <= max_azimuths: return None if moment == 'PHI': ret *= 0.5 # reshape matrix data bins = t_pol_header[0].num_gates nr_az = int(ret / bins) if bins < 1: # if num_gates is less than 1 (exception) bins = ret/360 if nr_az > 360: nr_az = 360 if nr_az < 360: print("WARNING incomplete sweep") if verbose: print("ret=%d" % ret) print("bins=%d" % bins) print("nr_az=%d" % nr_az) print("len(prd_data)=%d" % len(prd_data)) prd_data = prd_data[0: nr_az * bins] prd_data = np.reshape(prd_data, (nr_az, bins)) # reorder pol_header pol_header = (Header_stru * nr_az)() for i in range(0, nr_az): angle_start = Selex_Angle(t_pol_header[i].start_angle) pol_header[int(angle_start.az)] = t_pol_header[i] # Select scale prd_data_level = float_mapping(moment, pol_header[0].data_time, pol_header[0].scan_id, pol_header[0].ny_quest) if verbose: print("prd_data shape ", prd_data.shape) print("min/max prd_data: ", prd_data.min(), prd_data.max()) set(string.printable) print("prd_data scan_id ", pol_header[0].scan_id) print("prd_data host_id ", pol_header[0].host_id) print("data level ", prd_data_level[0:10]) for i in range(0, nr_az, 10): angle_start = Selex_Angle(pol_header[i].start_angle) angle_end = Selex_Angle(pol_header[i].end_angle) x = pol_header[i].num_gates / 2 print(("pol_header[%3d].num_gates: %d, time %d.%03d start_az/el:" " %6.1f/%4.1f end_az/el: %6.1f/%4.1f real[%d]=%6.2f" " ( raw=%5d)") % (i, pol_header[i].num_gates, pol_header[i].data_time, pol_header[i].data_time_residue, angle_start.az, angle_start.el, angle_end.az, angle_end.el, x, prd_data_level[prd_data[i, x]], prd_data[i, x])) if physic_value: ret_data.data = prd_data_level[prd_data] if masked_array: ret_data.data = np.ma.array( ret_data.data, mask=np.isnan(ret_data.data)) if bfile[1] == 'L': if moment in ('ZH', 'ZV', 'ZHC', 'ZVC'): prd_data_level[1] = np.nan ret_data.data = np.ma.masked_where( prd_data == 1, ret_data.data) else: ret_data.data = prd_data if masked_array: ret_data.data = np.ma.array( ret_data.data, mask=prd_data == 0) if bfile[1] == 'L': if moment in ('ZH', 'ZV', 'ZHC', 'ZVC'): prd_data_level[1] = np.nan ret_data.data = np.ma.masked_where( prd_data == 1, ret_data.data) # header prd_header['pid'] = bfile[0:3] prd_header['radar'] = bfile[2] prd_header['moment'] = moment prd_header['column'] = bins prd_header['row'] = nr_az # prd_header['elevation'] = "%03d" % pol_header[0].current_sweep prd_header['volume_time'] = int( pol_header[0].data_time - pol_header[0].data_time % 300 + 300) prd_header['time'] = time.strftime( '%y%j%H%M', time.gmtime(int(prd_header['volume_time']))) prd_header["quality"] = bfile[12] # if exists extended header, fill header if t_rad_header[0].FileId > 0 and t_rad_header[0].GateWidth > 0.: prd_header["FileId"] = t_rad_header[0].FileId prd_header["Version"] = t_rad_header[0].Version # prd_header["Spare1"] = t_rad_header[0].Spare1 # prd_header["Length"] = t_rad_header[0].Length prd_header["RadarName"] = ctypes.string_at( t_rad_header[0].RadarName) prd_header["ScanName"] = ctypes.string_at(t_rad_header[0].ScanName) prd_header["RadarLat"] = t_rad_header[0].RadarLat prd_header["RadarLon"] = t_rad_header[0].RadarLon prd_header["RadarHeight"] = t_rad_header[0].RadarHeight prd_header["SequenceSweep"] = t_rad_header[0].SequenceSweep prd_header["CurrentSweep"] = t_rad_header[0].CurrentSweep prd_header["TotalSweep"] = t_rad_header[0].TotalSweep prd_header["AntMode"] = t_rad_header[0].AntMode prd_header["Priority"] = t_rad_header[0].Priority # prd_header["Quality"] = t_rad_header[0].Quality prd_header["quality"] = t_rad_header[0].Quality # prd_header["Spare2"] = t_rad_header[0].Spare2 prd_header["RepeatTime"] = t_rad_header[0].RepeatTime prd_header["NumMoments"] = t_rad_header[0].NumMoments prd_header["GateWidth"] = t_rad_header[0].GateWidth prd_header["WaveLength"] = t_rad_header[0].WaveLength prd_header["Frequency"] = c_speed/(prd_header["WaveLength"]*1e-2) prd_header["PulseWidth"] = t_rad_header[0].PulseWidth prd_header["StartRange"] = t_rad_header[0].StartRange prd_header["MetaDataSize"] = t_rad_header[0].MetaDataSize # update with radar sweep radar prd_header['radar'] = prd_header["RadarName"][0] else: # specific radar metadata not available (old PM/PH/PL format) # from polar header prd_header["CurrentSweep"] = pol_header[0].current_sweep prd_header["TotalSweep"] = pol_header[0].total_sweep prd_header["AntMode"] = pol_header[0].ant_mode prd_header["RepeatTime"] = pol_header[0].repeat_time prd_header["GateWidth"] = pol_header[0].gate_width prd_header["StartRange"] = pol_header[0].start_range prd_header["Priority"] = pol_header[0].priority # from hard-coded table rname = prd_header['radar'] radar_def = get_radar_site_info() if rname in radar_def.keys(): prd_header["FileId"] = radar_def[rname]["FileId"] prd_header["Version"] = radar_def[rname]["Version"] prd_header["RadarName"] = radar_def[rname]["RadarName"] prd_header["ScanName"] = radar_def[rname]["ScanName"] prd_header["RadarLat"] = radar_def[rname]["RadarLat"] prd_header["RadarLon"] = radar_def[rname]["RadarLon"] prd_header["RadarHeight"] = radar_def[rname]["RadarHeight"] prd_header["Frequency"] = radar_def[rname]["Frequency"] prd_header["WaveLength"] = radar_def[rname]["WaveLength"] prd_header["PulseWidth"] = radar_def[rname]["PulseWidth"] prd_header["SequenceSweep"] = ( radar_def[rname]['SweepsOrder'].index( pol_header[0].current_sweep)) if bfile[1] == 'M': prd_header["NumMoments"] = radar_def[rname]['NumMomentsPM'] if bfile[1] == 'H': prd_header["NumMoments"] = radar_def[rname]['NumMomentsPH'] if bfile[1] == 'L': prd_header["NumMoments"] = radar_def[rname]['NumMomentsPL'] ret_data.header = prd_header ret_data.scale = prd_data_level ret_data.pol_header = pol_header # change parameters in header for i in range(nr_az): ret_data.pol_header[i].total_record = nr_az return ret_data
def onError(fmt, ap): msg = ctypes.c_char_p() ret = lib.lw_vasprintf(ctypes.byref(msg), fmt, ap) SextanteLog.addToLog(SextanteLog.LOG_ERROR, u"FAILURE: liblwgeom error is:\n%s" % msg.value)
def read_product(radar_file, physic_value=False, masked_array=False, verbose=False): """ Reads a METRANET cartesian data file Parameters ---------- radar_file : str file name physic_value : boolean If true returns the physical value. Otherwise the digital value masked_array : boolean If true returns a numpy masked array with NaN values masked. Otherwise returns a regular masked array with NaN values verbose : boolean If true prints out extra information Returns ------- ret_data : RadarData object An object containing the information read from the file. None if the file has not been properly read """ ret_data = RadarData() prd_header = {'row': 0, 'column': 0} # read ASCII data if verbose: print("physic_value: ", physic_value) print("File %s: read ASCII" % radar_file) try: with open(radar_file, 'rb') as data_file: lines = data_file.readlines() except OSError as ee: warn(str(ee)) print("Unable to read file '%s'" % radar_file) return None for t_line in lines: line = t_line.decode("utf-8").strip('\n') if line.find('end_header') == -1: data = line.split('=') prd_header[data[0]] = data[1] else: break # read BINARY data prdt_size = int(prd_header['column']) * int(prd_header['row']) if prdt_size < 1: print("Error, no size found row=%3d column=%3d" % (prd_header['row'], prd_header['column'])) return None if verbose: print("File %s: read BINARY data: expected %s bytes, " % (radar_file, prdt_size), end='') prd_data = np.zeros( [int(prd_header['row']), int(prd_header['column'])], np.ubyte) prd_data_level = np.zeros(256, np.float32) metranet_lib = get_library(verbose=verbose) ret = metranet_lib.py_decoder( ctypes.c_char_p(radar_file.encode('utf-8')), np.ctypeslib.as_ctypes(prd_data), ctypes.c_int(prdt_size), np.ctypeslib.as_ctypes(prd_data_level), ctypes.c_int(verbose)) # convert 0 at end of array with NAN conv_zero2nan = True i = len(prd_data_level) if prd_data_level.max() == prd_data_level.min(): prd_data_level = np.fromiter(xrange(256), dtype=np.uint32) else: while conv_zero2nan: i -= 1 if i < 0: conv_zero2nan = False elif prd_data_level[i] == 0.0: prd_data_level[i] = np.nan else: conv_zero2nan = False if verbose: print("Found %d bytes" % ret) print("prd_data_level[10] = %f" % prd_data_level[10]) print("min/max prd_data: %d/%d" % (prd_data.min(), prd_data.max())) print("first 100 bytes", prd_data[0:100, 0]) print("data level ", prd_data_level[0:10]) # ret_data = RadarData( # data=prd_data, header=prd_header, scale=prd_data_level) if physic_value: ret_data.data = prd_data_level[prd_data] if masked_array: ret_data.data = np.ma.array( ret_data.data, mask=np.isnan(ret_data.data)) ret_data.data = np.ma.masked_where(prd_data == 0, ret_data.data) else: ret_data.data = prd_data if masked_array: ret_data.data = np.ma.array( ret_data.data, mask=prd_data == 0) ret_data.header = prd_header ret_data.scale = prd_data_level return ret_data
def _set_clipboard_text(self, text): SDL_SetClipboardText(ctypes.c_char_p(text.encode()))
def init(self): if self.restoreInfo() == 0: raise mdsExceptions.TclFAILED_ESSENTIAL self.saveInfo() try: self.frames.setCompressOnPut(False) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot disable automatic compresson on put for frames node') raise mdsExceptions.TclFAILED_ESSENTIAL try: self.frames_metad.setCompressOnPut(False) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot disable automatic compresson on put for frames_metad node') raise mdsExceptions.TclFAILED_ESSENTIAL ###Object Parameters try: o_refl_temp = c_double(self.object_refl_temp.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object refletive temperature') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_atm_temp = c_double(self.object_atm_temp.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object atmosfere temperature') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_distance = c_double(self.object_distance.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object distance') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_emissivity = c_double(self.object_emissivity.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object emissivity') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_atm_hum = c_double(self.object_atm_hum.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object atmosfere humidity') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_optic_temp = c_double(self.object_optic_temp.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object optic temperature') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_optic_trans = c_double(self.object_optic_trans.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object optic transmission') raise mdsExceptions.TclFAILED_ESSENTIAL try: o_atm_trans = c_double(self.object_atm_trans.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid value for object atmosfere trasmission') raise mdsExceptions.TclFAILED_ESSENTIAL status = FLIRSC65X.flirLib.setObjectParameters(self.handle, o_refl_temp, o_atm_temp, o_distance, o_emissivity, o_atm_hum , o_optic_temp, o_optic_trans, o_atm_trans ) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Object Parameters : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Frame Rate try: frameRate = self.timing_frame_rate.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid frame rate value') raise mdsExceptions.TclFAILED_ESSENTIAL status = FLIRSC65X.flirLib.setFrameRateNew(self.handle, c_double(frameRate)) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Frame Rate : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Frame Area x=c_int(0) y=c_int(0) width=c_int(0) height=c_int(0) status = FLIRSC65X.flirLib.getReadoutArea(self.handle, byref(x), byref(y), byref(width), byref(height)) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Get Readout Area : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL #write data in mdsplus self.frame_x.putData(x.value) self.frame_y.putData(y.value) self.frame_width.putData(width.value) self.frame_height.putData(height.value) ###Focal Length try: focalLength = self.cam_setup_focal_length.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid Focal Length value') raise mdsExceptions.TclFAILED_ESSENTIAL if focalLength == '25': focalLengthInt=0 elif focalLength == '41': focalLengthInt=3 #offset to select the correct calibration curve using the Measurement Range ###Measurement Range try: measureRange = self.cam_setup_meas_range.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid measurement range value') raise mdsExceptions.TclFAILED_ESSENTIAL if measureRange == '-40...150': measRangeInt=0 elif measureRange == '100...650': measRangeInt=1 elif measureRange == '300...2000': measRangeInt=2 status = FLIRSC65X.flirLib.setMeasurementRange(self.handle, c_int(measRangeInt+focalLengthInt)) if status < 0: try: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Measurement Range : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL except: traceback.print_exc() ###Image Temperature try: frameTempUnit = self.frame_temp_unit.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid image temperature unit (Radiometric, 10mk, 100mk) value') raise mdsExceptions.TclFAILED_ESSENTIAL if frameTempUnit == 'Radiometric': frameTempUnitCode=c_int(0) elif frameTempUnit == 'LinearTemperature10mK': frameTempUnitCode=c_int(1) elif frameTempUnit == 'LinearTemperature100mK': frameTempUnitCode=c_int(2) status = FLIRSC65X.flirLib.setIrFormat(self.handle, frameTempUnitCode) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Image Temperature unit : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Frame Trigger mode try: burstDuration = self.timing_burst_dur.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid acquisition duration value') raise mdsExceptions.TclFAILED_ESSENTIAL try: triggerMode = self.timing_trig_mode.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid trigger mode value') raise mdsExceptions.TclFAILED_ESSENTIAL try: trigSource = self.timing_trig_source.data() except: if triggerMode == 'EXTERNAL': Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid trigger source value') raise mdsExceptions.TclFAILED_ESSENTIAL else: trigSource = array([0.]) print("OK " + triggerMode ) if triggerMode == 'EXTERNAL': #0=internal 1=external trigger trigModeCode=c_int(1) else: trigSource = array([0.]) trigModeCode=c_int(0) numTrigger = trigSource.size print("OK - NUM TRIGGER ", numTrigger) print("OK - Trigger Source ", trigSource) timeBase = Data.compile(" $ : $ + $ :(zero( size( $ ), 0.) + 1.) * 1./$", trigSource, trigSource, burstDuration, trigSource, frameRate) print("Data = " + Data.decompile(timeBase)) self.timing_time_base.putData(timeBase) status = FLIRSC65X.flirLib.setTriggerMode(self.handle, trigModeCode, c_double(burstDuration), numTrigger) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Internal/External Trigger : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Calibration try: calibAuto = self.cam_setup_calib_auto.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid auto calibration setup') raise mdsExceptions.TclFAILED_ESSENTIAL calibModeCode = c_int(1) if calibAuto == 'NO': try: calibTime = self.cam_setup_calib_time.data() calibModeCode = c_int(0) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid calibration duration value') raise mdsExceptions.TclFAILED_ESSENTIAL if numTrigger > 1 and (burstDuration + calibTime) > (trigSource[1] - trigSource[0]) : Data.execute('DevLogErr($1,$2)', self.nid, 'Calibration executed during acquisition') raise mdsExceptions.TclFAILED_ESSENTIAL status = FLIRSC65X.flirLib.setCalibMode(self.handle, calibModeCode) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Set Internal/External Trigger : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Streaming try: streamingMode = self.streaming_mode.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming mode setup') raise mdsExceptions.TclFAILED_ESSENTIAL if streamingMode == 'Stream and Store': streamingEnabled = c_int(1) storeEnabled = c_int(1) elif streamingMode == 'Only Stream': streamingEnabled = c_int(1) storeEnabled = c_int(0) else: #streamingMode == 'Only Store': streamingEnabled = c_int(0) storeEnabled = c_int(1) if streamingEnabled : try: if self.streaming_autoscale.data() == 'YES' : autoAdjustLimit = c_int(1) else: autoAdjustLimit = c_int(0) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming autoscale parameter value') raise mdsExceptions.TclFAILED_ESSENTIAL try: lowLim = c_int(self.streaming_lolim.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming low temperature limit parameter value') raise mdsExceptions.TclFAILED_ESSENTIAL try: highLim = c_int(self.streaming_hilim.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming high temperature limit parameter value') raise mdsExceptions.TclFAILED_ESSENTIAL try: streamingPort = c_int(self.streaming_port.data()) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming port parameter value') raise mdsExceptions.TclFAILED_ESSENTIAL try: streamingServer = self.streaming_server.data() except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid streaming server parameter value') raise mdsExceptions.TclFAILED_ESSENTIAL #fede 20161012 # else: # autoAdjustLimit = c_int(0) # streamingPort = c_int(8888) # lowLim = c_int(0) # highLim = c_int(36) # streamingServer = "localhost" print("lowLim ", lowLim) print("highLim ", highLim) print("frameTempUnitCode ", frameTempUnitCode) print("streamingPort ", streamingPort) print("streamingServer ", streamingServer) deviceName = str(self).rsplit(":",1) deviceName = deviceName[1] print("Device Name ", deviceName) #fede: recover device name and pass it to set streaming to overlay text on frame!!! status = FLIRSC65X.flirLib.setStreamingMode(self.handle, frameTempUnitCode, streamingEnabled, autoAdjustLimit, c_char_p(streamingServer), streamingPort, lowLim, highLim, c_char_p(deviceName)); if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot execute streaming setup mode : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Acquisition try: acqSkipFrameNumber = c_int( self.timing_skip_frame.data() ) except: Data.execute('DevLogErr($1,$2)', self.nid, 'Invalid acquisition decimation value') raise mdsExceptions.TclFAILED_ESSENTIAL status = FLIRSC65X.flirLib.setAcquisitionMode(self.handle, storeEnabled , acqSkipFrameNumber) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot execute acquisition setup mode : ' + self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL try: treePtr = c_void_p(0) status = FLIRSC65X.mdsLib.camOpenTree(c_char_p(self.getTree().name), c_int(self.getTree().shot), byref(treePtr)) if status == -1: Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot open tree') raise mdsExceptions.TclFAILED_ESSENTIAL except: traceback.print_exc() framesNid = self.frames.nid timebaseNid = self.timing_time_base.nid framesMetadNid = self.frames_metad.nid frame0TimeNid = self.frame0_time.nid status = FLIRSC65X.flirLib.setTreeInfo( self.handle, treePtr, framesNid, timebaseNid, framesMetadNid, frame0TimeNid) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot execute set tree info : '+self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL ###Auto Calibration status = FLIRSC65X.flirLib.executeAutoCalib(self.handle) if status < 0: FLIRSC65X.flirLib.getLastError(self.handle, self.error) Data.execute('DevLogErr($1,$2)', self.nid, 'Cannot Execute Auto Calibration : '+self.error.raw) raise mdsExceptions.TclFAILED_ESSENTIAL print('Init action completed.') return
def inflateInit2(strm, windowBits): return _zlib.inflateInit2_(ctypes.addressof(strm), windowBits, ctypes.c_char_p(ZLIB_VERSION), ctypes.sizeof(z_stream))
def PushOK(self): if self.sizeLine.text=='number of words' or self.sizeLine.text()=='number of symbols' or self.countLine.text()=='' or self.numberPuttern.text()=='': return self.textCombobox.clear() textComboboxRes.clear() self.sourceText.clear() # self.sourceText.clear() # self.sourceText.clear() resulText.clear() countText = self.countLine.text() a = int(countText) for i in range(a): self.textCombobox.addItem("Text " + str(i + 1)) textComboboxRes.addItem("Text " + str(i + 1)) text_num = a puttern_num=0 if self.comboBox.currentText()=="Random words": puttern_num=self.numberPuttern.text() if self.settingWordCombobox.currentText()=="Manual": self.pattern = self.enterWordEdit.text() c_pattern = ct.c_char_p(self.pattern.encode(encoding)) else: c_pattern=0 if self.comboBox.currentText() == "Text": list_ = [] for i in range(text_num): list_.append(book_parser()) new_list = (ct.c_char_p * text_num)(*map(str.encode, list_)) self.text=lib.make_parser_storage(new_list, c_pattern, text_num, len) else: text_num = a text_type = 0 puttern_num=0 path=path1 if self.comboBox.currentText() == "Full Random": text_type=0 path=path1 if self.comboBox.currentText() == "Random words": text_type=1 path=path2 puttern_num = self.numberPuttern.text() puttern_num=int(puttern_num) length = int(self.sizeLine.text()) print(length) if self.settingWordCombobox.currentText() == "Generate": self.text = (lib.make_text_storage(text_num, text_type, path, 0, puttern_num, length)) else: self.text = (lib.make_text_storage(text_num, text_type, path, c_pattern, puttern_num, length)) textik=self.text[0].Text.contents.haystack.decode(encoding) self.sourceText.append(self.text[0].Text.contents.haystack.decode(encoding)) if self.settingWordCombobox.currentText()=="Generate": self.enterWordEdit.clear() self.enterWordEdit.setStyleSheet("""font: normal; color: black""") self.enterWordEdit.setText(self.text[0].Pattern.contents.needle.decode(encoding)) numAlg=1 if self.algorithmCombobox.currentText()=="Boyer Moor Horspool": numAlg=0 elif self.algorithmCombobox.currentText()=="Naive Matcher": numAlg=1 elif self.algorithmCombobox.currentText()=="Rabin Karp": numAlg=2 elif self.algorithmCombobox.currentText()=="KMP": numAlg=3 self.algorithm_res = lib.make_result_storage(self.text, numAlg, text_num) numPatrern=0 i=0 printRes='' numPattern = 0 printRes = '' text = self.text[0].Text.contents.haystack.decode(encoding) i = 0 if self.comboBox.currentText() == "Random words": if self.algorithm_res[0].numberOfMatches != 0: while i < len(text): if i == self.algorithm_res[0].matchedShifts[numPattern]: for j in range(i, len(self.text[0].Pattern.contents.needle.decode(encoding))+i): redText = "<span style=\" font: bold; color: #ffa500;\">" redText += (text[j]) printRes += (redText) numPattern += 1 i += len(self.text[0].Pattern.contents.needle.decode(encoding)) else: blackText = "<span style=\" font: normal; color: black;\">" blackText += text[i] printRes += (blackText) i += 1 resulText.append(printRes) else: resulText.append(self.text[0].Text.contents.haystack.decode(encoding)) else: if self.algorithm_res[0].numberOfMatches != 0: while i < len(text): if i == self.algorithm_res[0].matchedShifts[numPattern]: if i+1==self.algorithm_res[0].matchedShifts[numPattern+1]: redText = "<span style=\" font: bold; color: #ffa500;\">" redText += (text[i]) printRes += (redText) i+=1 else: for j in range(i, i + len(self.text[0].Pattern.contents.needle.decode(encoding))): redText = "<span style=\" font: bold; color: #ffa500;\">" redText += (text[j]) printRes += (redText) i+=len(self.text[0].Pattern.contents.needle.decode(encoding)) numPattern += 1 else: blackText = "<span style=\" font: normal; color: black;\">" blackText += text[i] printRes += (blackText) i += 1 resulText.append(printRes) else: resulText.append(self.text[0].Text.contents.haystack.decode(encoding)) statictic = lib.make_statictic(self.algorithm_res, text_num) numberOfMatches.setText("Number of matches: " + str(self.algorithm_res[0].numberOfMatches)) numOfComparises.setText("Number of comparisons: " + str(self.algorithm_res[0].numOfCompares)) numOfExtraOps.setText("Number of extra operations: " + str(self.algorithm_res[0].numOfExtraOps)) workTime.setText("Work time: " + str(self.algorithm_res[0].workTime)) memoryWaste.setText("Memory waste: " + str(self.algorithm_res[0].memoryWaste)) genPattern.setText("Pattern: "+ self.enterWordEdit.text()) genNumOfComparises.setText("Number of comparisons: " + str(statictic.contents.numOfCompares)) genNumOfExtraOps.setText("Number of extra operations: " + str(statictic.contents.numOfExtraOps)) genWorkTime.setText("Work time: " + str(statictic.contents.workTime)) genMemoryWaste.setText("Memory waste: " + str(statictic.contents.memoryWaste)) self.textCombobox.currentTextChanged.connect(self.ChooseText) textComboboxRes.currentTextChanged.connect(self.ChooseTextRes)
def inflateInit(strm): return _zlib.inflateInit_(ctypes.addressof(strm), ctypes.c_char_p(ZLIB_VERSION), ctypes.sizeof(z_stream))
def deflateInit(strm, level): return _zlib.deflateInit_(ctypes.addressof(strm), level, ctypes.c_char_p(ZLIB_VERSION), ctypes.sizeof(z_stream))
def make_rdm4(self, state, norb, nelec, dt=numpy.dtype('Float64'), filetype="binary", link_index=None, **kwargs): import os if self.has_fourpdm == False: self.twopdm = False self.threepdm = False self.extraline.append('threepdm\n') self.extraline.append('fourpdm\n') writeDMRGConfFile(self, nelec, False) if self.verbose >= logger.DEBUG1: inFile = self.configFile #inFile = os.path.join(self.scratchDirectory,self.configFile) logger.debug1(self, 'Block Input conf') logger.debug1(self, open(inFile, 'r').read()) executeBLOCK(self) if self.verbose >= logger.DEBUG1: outFile = self.outputFile #outFile = os.path.join(self.scratchDirectory,self.outputFile) logger.debug1(self, open(outFile).read()) self.has_fourpdm = True self.has_threepdm = True self.extraline.pop() # The binary files coming from STACKBLOCK and BLOCK are different: # - STACKBLOCK does not have 4RDM # If it had, it would probably come in a 8-fold symmetr which must unpacked # using "libunpack.unpackE4" (see lib/icmpspt/icmpspt.c) # - BLOCK just writes a list of all values, this is directly read # using "unpackE4_BLOCK" (see below) if (filetype == "binary"): fname = os.path.join(self.scratchDirectory, "node0", "spatial_fourpdm.%d.%d.bin" % (state, state)) if 'stackblock' in settings.BLOCKEXE: print 'Reading binary 4RDM from STACKBLOCK' fnameout = os.path.join( self.scratchDirectory, "node0", "spatial_fourpdm.%d.%d.bin.unpack" % (state, state)) libunpack.unpackE4(ctypes.c_char_p(fname), ctypes.c_char_p(fnameout), ctypes.c_int(norb)) E4 = numpy.fromfile(fnameout, dtype=numpy.dtype('Float64')) E4 = numpy.reshape( E4, (norb, norb, norb, norb, norb, norb, norb, norb), order='F') else: print 'Reading binary 4RDM from BLOCK' E4 = DMRGCI.unpackE4_BLOCK(self, fname, norb) # The 4RDMs written by "Fourpdm_container::save_spatial_npdm_text" in BLOCK and STACKBLOCK # are written as E4[i1,j2,k3,l4,m4,n3,o2,p1] # and are stored here as E4[i1,j2,k3,l4,p1,o2,n3,m4] # This is done with SQA in mind. else: print 'Reading text-file 4RDM' fname = os.path.join(self.scratchDirectory, "node0", "spatial_fourpdm.%d.%d.txt" % (state, state)) f = open(fname, 'r') lines = f.readlines() E4 = numpy.zeros(shape=(norb, norb, norb, norb, norb, norb, norb, norb), dtype=dt, order='F') assert (int(lines[0]) == norb) for line in lines[1:]: linesp = line.split() if (len(linesp) != 9): continue a, b, c, d, e, f, g, h, integral = int(linesp[0]), int( linesp[1]), int(linesp[2]), int(linesp[3]), int( linesp[4]), int(linesp[5]), int(linesp[6]), int( linesp[7]), float(linesp[8]) if (False): up_indexes = [a, b, c, d] dn_indexes = [h, g, f, e] for i in range(4): for j in range(4): if (i == j): continue for k in range(4): if ((i == k) or (j == k)): continue for l in range(4): if ((i == l) or (j == l) or (k == l)): continue E4[up_indexes[i],up_indexes[j],up_indexes[k],up_indexes[l],\ dn_indexes[i],dn_indexes[j],dn_indexes[k],dn_indexes[l]] = integral else: self.populate(E4, [a, b, c, d, h, g, f, e], integral) print '' return E4
def deflateInit2(strm, level, method, windowBits, memLevel, strategy): return _zlib.deflateInit2_(ctypes.addressof(strm), level, method, windowBits, memLevel, strategy, ctypes.c_char_p(ZLIB_VERSION), ctypes.sizeof(z_stream))
def _make_atomic_symbol_function(handle): """Create an atomic symbol function by handle and funciton name.""" name = ctypes.c_char_p() desc = ctypes.c_char_p() key_var_num_args = ctypes.c_char_p() num_args = mx_uint() arg_names = ctypes.POINTER(ctypes.c_char_p)() arg_types = ctypes.POINTER(ctypes.c_char_p)() arg_descs = ctypes.POINTER(ctypes.c_char_p)() check_call( _LIB.MXSymbolGetAtomicSymbolInfo(handle, ctypes.byref(name), ctypes.byref(desc), ctypes.byref(num_args), ctypes.byref(arg_names), ctypes.byref(arg_types), ctypes.byref(arg_descs), ctypes.byref(key_var_num_args))) param_str = ctypes2docstring(num_args, arg_names, arg_types, arg_descs) key_var_num_args = py_str(key_var_num_args.value) func_name = py_str(name.value) desc = py_str(desc.value) if key_var_num_args: desc += '\nThis function support variable length of positional input.' doc_str = ('%s\n\n' + '%s\n' + 'name : string, optional.\n' + ' Name of the resulting symbol.\n\n' + 'Returns\n' + '-------\n' + 'symbol: Symbol\n' + ' The result symbol.') doc_str = doc_str % (desc, param_str) def creator(*args, **kwargs): """Activation Operator of Neural Net. The parameters listed below can be passed in as keyword arguments. Parameters ---------- name : string, required. Name of the resulting symbol. Returns ------- symbol: Symbol the resulting symbol """ param_keys = [] param_vals = [] symbol_kwargs = {} name = kwargs.pop('name', None) if key_var_num_args and key_var_num_args not in kwargs: param_keys.append(c_str(key_var_num_args)) param_vals.append(c_str(str(len(args)))) for k, v in kwargs.items(): if isinstance(v, Symbol): symbol_kwargs[k] = v else: param_keys.append(c_str(k)) param_vals.append(c_str(str(v))) # create atomic symbol param_keys = c_array(ctypes.c_char_p, param_keys) param_vals = c_array(ctypes.c_char_p, param_vals) sym_handle = SymbolHandle() check_call( _LIB.MXSymbolCreateAtomicSymbol(handle, mx_uint(len(param_keys)), param_keys, param_vals, ctypes.byref(sym_handle))) if len(args) != 0 and len(symbol_kwargs) != 0: raise TypeError( '%s can only accept input' 'Symbols either as positional or keyword arguments, not both' % func_name) if key_var_num_args and len(symbol_kwargs) != 0: raise ValueError( 'This function support variable length of Symbol arguments.\n' + 'Please pass all the input Symbols via positional arguments' + ' instead of keyword arguments.') s = Symbol(sym_handle) hint = func_name.lower() name = NameManager.current.get(name, hint) s._compose(*args, name=name, **symbol_kwargs) return s creator.__name__ = func_name creator.__doc__ = doc_str return creator
def compile(self, **options): """Perform Compliation The valid compiler options are * - -g (enable generation of debugging information) * - -opt= * - 0 (disable optimizations) * - 3 (default, enable optimizations) * - -arch= * - compute_20 (default) * - compute_30 * - compute_35 * - -ftz= * - 0 (default, preserve denormal values, when performing * single-precision floating-point operations) * - 1 (flush denormal values to zero, when performing * single-precision floating-point operations) * - -prec-sqrt= * - 0 (use a faster approximation for single-precision * floating-point square root) * - 1 (default, use IEEE round-to-nearest mode for * single-precision floating-point square root) * - -prec-div= * - 0 (use a faster approximation for single-precision * floating-point division and reciprocals) * - 1 (default, use IEEE round-to-nearest mode for * single-precision floating-point division and reciprocals) * - -fma= * - 0 (disable FMA contraction) * - 1 (default, enable FMA contraction) * """ # stringify options opts = [] if 'debug' in options: if options.pop('debug'): opts.append('-g') if options.get('opt'): opts.append('-opt=%d' % options.pop('opt')) if options.get('arch'): opts.append('-arch=%s' % options.pop('arch')) other_options = ( 'ftz', 'prec_sqrt', 'prec_div', 'fma', ) for k in other_options: if k in options: v = int(bool(options.pop(k))) opts.append('-%s=%d' % (k.replace('_', '-'), v)) # If there are any option left if options: optstr = ', '.join(map(repr, options.keys())) raise NvvmError("unsupported option {0}".format(optstr)) # compile c_opts = (c_char_p * len(opts))(*[c_char_p(x.encode('utf8')) for x in opts]) err = self.driver.nvvmCompileProgram(self._handle, len(opts), c_opts) self._try_error(err, 'Failed to compile\n') # get result reslen = c_size_t() err = self.driver.nvvmGetCompiledResultSize(self._handle, byref(reslen)) self._try_error(err, 'Failed to get size of compiled result.') ptxbuf = (c_char * reslen.value)() err = self.driver.nvvmGetCompiledResult(self._handle, ptxbuf) self._try_error(err, 'Failed to get compiled result.') # get log self.log = self.get_log() return ptxbuf[:]
def _cu_check_error(result): if result != CUDA_SUCCESS: _error_str = c_char_p() _cuda_lib.cuGetErrorString(result, byref(_error_str)) raise NVError('Device API Error %d: %s' % (result, _error_str.value.decode()))
def make_rdm3(self, state, norb, nelec, dt=numpy.dtype('Float64'), filetype="binary", link_index=None, **kwargs): import os if self.has_threepdm == False: self.twopdm = False self.extraline.append('threepdm\n') writeDMRGConfFile(self, nelec, False) if self.verbose >= logger.DEBUG1: inFile = self.configFile #inFile = os.path.join(self.scratchDirectory,self.configFile) logger.debug1(self, 'Block Input conf') logger.debug1(self, open(inFile, 'r').read()) executeBLOCK(self) if self.verbose >= logger.DEBUG1: outFile = self.outputFile #outFile = os.path.join(self.scratchDirectory,self.outputFile) logger.debug1(self, open(outFile).read()) self.has_threepdm = True self.extraline.pop() # The binary files coming from STACKBLOCK and BLOCK are different # - STACKBLOCK uses the 6-fold symmetry, this must be unpacked # using "libunpack.unpackE3" (see lib/icmpspt/icmpspt.c) # - BLOCK just writes a list of all values, this is directly read # using "unpackE3_BLOCK" (see below) if (filetype == "binary"): fname = os.path.join(self.scratchDirectory, "node0", "spatial_threepdm.%d.%d.bin" % (state, state)) if 'stackblock' in settings.BLOCKEXE: print 'Reading binary 3RDM from STACKBLOCK' fnameout = os.path.join( self.scratchDirectory, "node0", "spatial_threepdm.%d.%d.bin.unpack" % (state, state)) libunpack.unpackE3(ctypes.c_char_p(fname), ctypes.c_char_p(fnameout), ctypes.c_int(norb)) E3 = numpy.fromfile(fnameout, dtype=numpy.dtype('Float64')) E3 = numpy.reshape(E3, (norb, norb, norb, norb, norb, norb), order='F') else: print 'Reading binary 3RDM from BLOCK' E3 = DMRGCI.unpackE3_BLOCK(self, fname, norb) # The 3RDMs written by "Threepdm_container::save_spatial_npdm_text" in BLOCK and STACKBLOCK # are written as E3[i1,j2,k3,l3,m2,n1] # and are stored here as E3[i1,j2,k3,n1,m2,l3] # This is done with SQA in mind. else: print 'Reading text-file 3RDM' fname = os.path.join(self.scratchDirectory, "node0", "spatial_threepdm.%d.%d.txt" % (state, state)) f = open(fname, 'r') lines = f.readlines() E3 = numpy.zeros(shape=(norb, norb, norb, norb, norb, norb), dtype=dt, order='F') assert (int(lines[0]) == norb) for line in lines[1:]: linesp = line.split() if (len(linesp) != 7): continue a, b, c, d, e, f, integral = int(linesp[0]), int( linesp[1]), int(linesp[2]), int(linesp[3]), int( linesp[4]), int(linesp[5]), float(linesp[6]) if (False): E3[a, b, c, f, e, d] = integral E3[a, c, b, f, d, e] = integral E3[b, a, c, e, f, d] = integral E3[b, c, a, e, d, f] = integral E3[c, a, b, d, f, e] = integral E3[c, b, a, d, e, f] = integral else: self.populate(E3, [a, b, c, f, e, d], integral) print '' return E3
def get_string(target, addr): if target is None: return ctypes.c_char_p(addr).value.decode("latin1") return target.read_string(addr)
def _arg_to_ctypes(cls, *value): if value and isinstance(value[0], bytes): return ctypes.c_char_p(value[0]) else: return super(CTypesPtr, cls)._arg_to_ctypes(*value)
def read_model(self, path): path_char = ctypes.c_char_p(path.encode()) model = _lib.ffm_load_model_c_string(path_char) self._model = model return self
def c_str(string): return ctypes.c_char_p(string)
def connect(self, address, rack, slot): logger.info("connecting to %s rack %s slot %s" % (address, rack, slot)) return clib.Cli_ConnectTo(self.pointer, c_char_p(address), c_int(rack), c_int(slot))
def save_model(self, path): model = self._model path_char = ctypes.c_char_p(path.encode()) _lib.ffm_save_model_c_string(model, path_char)
def set_session_password(self, password): """Send the password to the PLC to meet its security level.""" assert len(password) <= 8, 'maximum password length is 8' return clib.Cli_SetSessionPassword(self.pointer, c_char_p(password))
def __init__(self, options=None): if options is None: options = DetectorOptions() self.options = options # detect OS to get extension for DLL uname0 = os.uname()[0] if uname0 == 'Darwin': extension = '.dylib' else: extension = '.so' # TODO test on windows? filename = searchpath = Path(__file__).parent / ('lib/libapriltag' + extension) print(filename) # load the C library and store it as a class variable # note: prefer OS install to local! try: self.libc = ctypes.CDLL(filename) except OSError: selfdir = os.path.dirname(__file__) relpath = os.path.join(selfdir, '../build/lib/', filename) if not os.path.exists(relpath): raise self.libc = ctypes.CDLL(relpath) # declare return types of libc function self._declare_return_types() # create the c-_apriltag_detector object self.tag_detector = self.libc.apriltag_detector_create() self.tag_detector.contents.nthreads = int(options.nthreads) self.tag_detector.contents.quad_decimate = float(options.quad_decimate) self.tag_detector.contents.quad_sigma = float(options.quad_sigma) self.tag_detector.contents.refine_edges = int(options.refine_edges) self.tag_detector.contents.refine_decode = int(options.refine_decode) self.tag_detector.contents.refine_pose = int(options.refine_pose) self.tag_detector.contents.debug = int(options.debug) print("In Detector.__init__") print(self.tag_detector.contents.debug) if options.quad_contours: self.libc.apriltag_detector_enable_quad_contours( self.tag_detector, 1) self.inverse = options.inverse self.families = [] flist = self.libc.apriltag_family_list() for i in range(flist.contents.size): ptr = ctypes.c_char_p() self.libc.zarray_get(flist, i, ctypes.byref(ptr)) self.families.append(ctypes.string_at(ptr)) #print(ptr.value.decode("utf-8")) if options.families == 'all': families_list = self.families elif isinstance(options.families, list): families_list = options.families else: families_list = [ n for n in re.split(r'\W+', options.families) if n ] #print("##"+repr(families_list)) # add tags for family in families_list: self.add_tag_family(family)