def setUp(self): super(TestRing, self).setUp() self.testdir = mkdtemp() self.testgz = os.path.join(self.testdir, 'whatever.ring.gz') self.intended_replica2part2dev_id = [ array.array('H', [0, 1, 0, 1]), array.array('H', [0, 1, 0, 1]), array.array('H', [3, 4, 3, 4])] self.intended_devs = [{'id': 0, 'region': 0, 'zone': 0, 'weight': 1.0, 'ip': '10.1.1.1', 'port': 6000, 'replication_ip': '10.1.0.1', 'replication_port': 6066}, {'id': 1, 'region': 0, 'zone': 0, 'weight': 1.0, 'ip': '10.1.1.1', 'port': 6000, 'replication_ip': '10.1.0.2', 'replication_port': 6066}, None, {'id': 3, 'region': 0, 'zone': 2, 'weight': 1.0, 'ip': '10.1.2.1', 'port': 6000, 'replication_ip': '10.2.0.1', 'replication_port': 6066}, {'id': 4, 'region': 0, 'zone': 2, 'weight': 1.0, 'ip': '10.1.2.2', 'port': 6000, 'replication_ip': '10.2.0.1', 'replication_port': 6066}] self.intended_part_shift = 30 self.intended_reload_time = 15 ring.RingData( self.intended_replica2part2dev_id, self.intended_devs, self.intended_part_shift).save(self.testgz) self.ring = ring.Ring( self.testdir, reload_time=self.intended_reload_time, ring_name='whatever')
def test_bug_782369(self): for i in range(10): b = array.array('B', range(64)) rc = sys.getrefcount(10) for i in range(10): b = array.array('B', range(64)) self.assertEqual(rc, sys.getrefcount(10))
def test_mul(self): a = 5*array.array(self.typecode, self.example) self.assertEqual( a, array.array(self.typecode, 5*self.example) ) a = array.array(self.typecode, self.example)*5 self.assertEqual( a, array.array(self.typecode, self.example*5) ) a = 0*array.array(self.typecode, self.example) self.assertEqual( a, array.array(self.typecode) ) a = (-1)*array.array(self.typecode, self.example) self.assertEqual( a, array.array(self.typecode) ) a = 5 * array.array(self.typecode, self.example[:1]) self.assertEqual( a, array.array(self.typecode, [a[0]] * 5) ) self.assertRaises(TypeError, a.__mul__, "bad")
def CreateGraph(self, name): x = array("d") y = array("d") x_err = array("d") y_errl = array("d") y_errh = array("d") for point in self.data: x.append(float(point.mass)) x_err.append(0.) if name == "Observed": y.append(float(point.observed)) y_errl.append(float(0.)) y_errh.append(float(0.)) else: y.append(float(point.expected)) if not name.find("1") == -1: y_errl.append(float(point.expectedMinus1Sigma)) y_errh.append(float(point.expectedPlus1Sigma)) elif not name.find("2") == -1: y_errl.append(float(point.expectedMinus2Sigma)) y_errh.append(float(point.expectedPlus2Sigma)) else: y_errl.append(float(0.)) y_errh.append(float(0.)) graph = ROOT.TGraphAsymmErrors(len(x),x,y,x_err,x_err,y_errl,y_errh) graph.SetName(name) return graph
def test_pop(self): a = array.array(self.typecode) self.assertRaises(IndexError, a.pop) a = array.array(self.typecode, 2*self.example) self.assertRaises(TypeError, a.pop, 42, 42) self.assertRaises(TypeError, a.pop, None) self.assertRaises(IndexError, a.pop, len(a)) self.assertRaises(IndexError, a.pop, -len(a)-1) self.assertEntryEqual(a.pop(0), self.example[0]) self.assertEqual( a, array.array(self.typecode, self.example[1:]+self.example) ) self.assertEntryEqual(a.pop(1), self.example[2]) self.assertEqual( a, array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example) ) self.assertEntryEqual(a.pop(0), self.example[1]) self.assertEntryEqual(a.pop(), self.example[-1]) self.assertEqual( a, array.array(self.typecode, self.example[3:]+self.example[:-1]) )
def test_len(self): a = array.array(self.typecode) a.append(self.example[0]) self.assertEqual(len(a), 1) a = array.array(self.typecode, self.example) self.assertEqual(len(a), len(self.example))
def test_cmp(self): a = array.array(self.typecode, self.example) self.assertIs(a == 42, False) self.assertIs(a != 42, True) self.assertIs(a == a, True) self.assertIs(a != a, False) self.assertIs(a < a, False) self.assertIs(a <= a, True) self.assertIs(a > a, False) self.assertIs(a >= a, True) al = array.array(self.typecode, self.smallerexample) ab = array.array(self.typecode, self.biggerexample) self.assertIs(a == 2*a, False) self.assertIs(a != 2*a, True) self.assertIs(a < 2*a, True) self.assertIs(a <= 2*a, True) self.assertIs(a > 2*a, False) self.assertIs(a >= 2*a, False) self.assertIs(a == al, False) self.assertIs(a != al, True) self.assertIs(a < al, False) self.assertIs(a <= al, False) self.assertIs(a > al, True) self.assertIs(a >= al, True) self.assertIs(a == ab, False) self.assertIs(a != ab, True) self.assertIs(a < ab, True) self.assertIs(a <= ab, True) self.assertIs(a > ab, False) self.assertIs(a >= ab, False)
def load_from_file(self, filename): print('Загружаю граф из файла: ' + filename) with open(filename) as f: (n, _nlinks) = (map(int, f.readline().split())) self._titles = [] # список названий статей self._sizes = array.array('L', [0]*n) # список с размерами i-ой статьи self._links = array.array('L', [0]*_nlinks) # список список ссылок на статьи - метод Compressed Sparse Row self._redirect = array.array('B', [0]*n) # флаг перенаправления self._offset = array.array('L', [0]*(n+1)) # в i-ой ячейке содержится информация с какого номера начинаются ссылки в self._links для i-й статьи current_link = 0 for i in range(n): __title = f.readline() self._titles.append(__title.rstrip()) (size, redirect, amout_links) = (map(int, f.readline().split())) self._sizes[i] = size self._redirect[i] = redirect for j in range(current_link, current_link + amout_links): self._links[j] = int(f.readline()) current_link += amout_links if n > 0: self._offset[i+1] = self._offset[i] + amout_links print('Граф загружен')
def load_from_file(self, filename): print('Загружаю граф из файла: ' + filename) with open(filename) as f: s=f.readline() s=s.split() (n, _nlinks) = (int(s[0]), int(s[1])) # TODO: прочитать из файла self._titles = [] self._edges=array.array('L',[0]*_nlinks) self._sizes = array.array('L', [0]*n) self._links = array.array('L', [0]*_nlinks) self._redirect = array.array('B', [0]*n) self._offset = array.array('L', [0]*(n+1)) # TODO: прочитать граф из файла for i in range(int(s[0])): k=f.readline() self._titles.append(k[:-1]) k=f.readline() k=k.split() self._sizes[i]=int(k[0]) self._redirect[i]=int(k[1]) self._links[i]=int(k[2]) self._offset[i+1]=self._offset[i]+self._links[i] #исправить тип integer for j in range(int(k[2])): m=f.readline() self._edges[j+self._offset[i]]=int(m) print('Граф загружен')
def __init__(self, *args, **kwargs): name = kwargs.get('name', None) title = kwargs.get('title', None) params = self._parse_args(*args) if params[0]['bins'] is None and params[1]['bins'] is None: Object.__init__(self, name, title, params[0]['nbins'], params[0]['low'], params[0]['high'], params[1]['nbins'], params[1]['low'], params[1]['high']) elif params[0]['bins'] is None and params[1]['bins'] is not None: Object.__init__(self, name, title, params[0]['nbins'], params[0]['low'], params[0]['high'], params[1]['nbins'], array('d', params[1]['bins'])) elif params[0]['bins'] is not None and params[1]['bins'] is None: Object.__init__(self, name, title, params[0]['nbins'], array('d', params[0]['bins']), params[1]['nbins'], params[1]['low'], params[1]['high']) else: Object.__init__(self, name, title, params[0]['nbins'], array('d', params[0]['bins']), params[1]['nbins'], array('d', params[1]['bins'])) self._post_init(**kwargs)
def load_from_file(self, filename): print('Загружаю граф из файла: ' + filename) with open(filename) as f: file_data = f.readline().split() self._n = int(file_data[0]) #n - количество статей self._nlinks = int(file_data[-1]) #nlinks - количество ссылок во всех статьях self._titles = [] #titles - названия статей self._sizes = array.array('L', [0]*self._n) #sizes - размеры статей self._links = array.array('L', [0]*self._nlinks) #links - количество ссылок в статьях self._redirect = array.array('B', [0]*self._n) #redirect - флаги перенаправления self._offset = array.array('L', [0]*(self._n+1)) # offset - номер статьи, на которую ссылается статья links_iterator = 0 for title_number in range(self._n): self._titles.append(f.readline()) title_size, redirect_flag, title_links_number = [int(x) for x in f.readline().split()] self._sizes[title_number] = title_size self._redirect[title_number] = redirect_flag if title_number == 0: self._offset[title_number] = links_iterator for link_number in range(title_links_number): self._links[links_iterator] = (int(f.readline())) links_iterator += 1 print('Граф загружен')
def testGetAccumulate(self): group = self.WIN.Get_group() size = group.Get_size() group.Free() for array in arrayimpl.ArrayTypes: for typecode in arrayimpl.TypeMap: for count in range(self.COUNT_MIN, 10): for rank in range(size): ones = array([1]*count, typecode) sbuf = array(range(count), typecode) rbuf = array(-1, typecode, count+1) gbuf = array(-1, typecode, count+1) for op in (MPI.SUM, MPI.PROD, MPI.MAX, MPI.MIN, MPI.REPLACE, MPI.NO_OP): self.WIN.Lock(rank) self.WIN.Put(ones.as_mpi(), rank) self.WIN.Flush(rank) r = self.WIN.Rget_accumulate(sbuf.as_mpi(), rbuf.as_mpi_c(count), rank, op=op) r.Wait() self.WIN.Flush(rank) r = self.WIN.Rget(gbuf.as_mpi_c(count), rank) r.Wait() self.WIN.Unlock(rank) # for i in range(count): self.assertEqual(sbuf[i], i) self.assertEqual(rbuf[i], 1) self.assertEqual(gbuf[i], op(1, i)) self.assertEqual(rbuf[-1], -1) self.assertEqual(gbuf[-1], -1)
def proc_gentlink(self): #get GELINK Header info cmd='TASKSTATS\0' mlen=len(cmd) + 4 msg_ts=array.array(str('B')) msg_ts.fromstring(struct.pack("BBxx", CTRL_CMD_GETFAMILY, 0)) msg_ts.fromstring(struct.pack("HH", mlen, CTRL_ATTR_FAMILY_NAME)) msg_ts.fromstring(cmd) tmp=((4 - (len(msg_ts) % 4)) & 0x3) msg_ts.fromstring('\0' * ((4 - (len(cmd) % 4)) & 0x3)) nlmhdr_msg=array.array(str('B'),struct.pack(str('=IHHII'), len(msg_ts) + 16, NETLINK_GENERIC, NLM_F_REQUEST, 0, 0)) nlmhdr_msg.extend(msg_ts) self.socket.send(nlmhdr_msg) data = self.socket.recv(65536)#(16384) data=self.unpack_nlhdr(data) data=self.unpack_genlhdr(data) while len(data) > 0: data=self.unpack_attr_hdr(data) # if self.flags & 0x2 == 0: if debug>0: print "End of receiving message!" return
def vectorizer(self): """ Turns tokens into a word vector in the bag of words format. Also builds a vocabulary which contains all of the unique words from the tokens. """ vocab = defaultdict(None) vocab.default_factory = vocab.__len__ indices = array.array(str('i')) indptr = array.array(str('i')) indptr.append(0) for tokens in Bow.tokenizer(self): for token in tokens: indices.append(vocab[token]) indptr.append(len(indices)) vocab = dict(vocab) values = np.ones(len(indices), dtype=np.int) word_matrix = sp.csr_matrix((values, indices, indptr), shape = (len(indptr) - 1, len(vocab))) word_matrix.sum_duplicates() self.vocab = vocab self.word_matrix = word_matrix
def doc2bow(tokens, vocab): """ Transforms tokens into bag of word representation from a given vocabulary, a port of the gensim function of the same name Parameters ---------- tokens: list a list of tokens from a body of text vocab : dict a dictionary of format {word : index} Returns ------- word_vector : scipy.sparse.csr_matrix a sparse vector bag of word representation of the given tokens """ indices = array.array(str('i')) indptr = array.array(str('i')) indptr.append(0) for token in tokens: indices.append(vocab[token]) indptr.append(len(indices)) values = np.ones(len(indices)) word_vector = sp.csr_matrix((values, indices, indptr), shape = (len(indptr) - 1, len(vocab))) word_vector.sum_duplicates() return word_vector
def __init__(self, data): self.raw = data self.u16s = array.array('H', data) assert(self.u16s.itemsize == 2) self.u32s = array.array('I', data) assert(self.u32s.itemsize == 4) stream = Reader(data) # parse header stream.read(36) if stream.u32() != 0x70: print('Warning, unexpected header size!') if stream.u32() != 0x12345678: print('Warning, unexpected endianess tag!') self.link = SizeOff(stream) self.map_off = stream.u32() self.string_ids = SizeOff(stream) self.type_ids = SizeOff(stream) self.proto_ids = SizeOff(stream) self.field_ids = SizeOff(stream) self.method_ids = SizeOff(stream) self.class_defs = SizeOff(stream) self.data = SizeOff(stream) defs = self.class_defs self.classes = [] for i in range(defs.size): self.classes.append(DexClass(self, defs.off, i))
def __init__(self, width, height): self.width = int(width) self.height = height try: self._b = [ array('c', ' '*int(width)) for line in range(height) ] except TypeError: self._b = [ array('u', ' '*int(width)) for line in range(height) ]
def __create_pie_image(self): self.__create_on_disk() vals=[] colors=[] for n,col in zip((self.n_fails,self.n_nulls,self.n_successes,self.n_skiped),(kRed,kYellow,kGreen,kBlue)): if n!=0: vals.append(n) colors.append(col) valsa=array('f',vals) colorsa=array('i',colors) can = TCanvas("cpie","TPie test",100,100); try: pie = TPie("ThePie",self.name,len(vals),valsa,colorsa); label_n=0 if self.n_fails!=0: pie.SetEntryLabel(label_n, "Fail: %.1f(%i)" %(self.get_fail_rate(),self.n_fails) ); label_n+=1 if self.n_nulls!=0: pie.SetEntryLabel(label_n, "Null: %.1f(%i)" %(self.get_null_rate(),self.n_nulls) ); label_n+=1 if self.n_successes!=0: pie.SetEntryLabel(label_n, "Success: %.1f(%i)" %(self.get_success_rate(),self.n_successes) ); if self.n_skiped!=0: pie.SetEntryLabel(label_n, "Skipped: %.1f(%i)" %(self.get_skiped_rate(),self.n_skiped)); pie.SetY(.52); pie.SetAngularOffset(0.); pie.SetLabelsOffset(-.3); #pie.SetLabelFormat("#splitline{%val (%perc)}{%txt}"); pie.Draw("3d nol"); can.Print(self.get_summary_chart_name()); except: print("self.name = %s" %self.name) print("len(vals) = %s (vals=%s)" %(len(vals),vals)) print("valsa = %s" %valsa) print("colorsa = %s" %colorsa)
def __init__(self, *args, **kwargs): params = self._parse_args(args) name = kwargs.pop('name', None) title = kwargs.pop('title', None) if params[0]['bins'] is None and params[1]['bins'] is None: super(Hist2D, self).__init__( params[0]['nbins'], params[0]['low'], params[0]['high'], params[1]['nbins'], params[1]['low'], params[1]['high'], name=name, title=title) elif params[0]['bins'] is None and params[1]['bins'] is not None: super(Hist2D, self).__init__( params[0]['nbins'], params[0]['low'], params[0]['high'], params[1]['nbins'], array('d', params[1]['bins']), name=name, title=title) elif params[0]['bins'] is not None and params[1]['bins'] is None: super(Hist2D, self).__init__( params[0]['nbins'], array('d', params[0]['bins']), params[1]['nbins'], params[1]['low'], params[1]['high'], name=name, title=title) else: super(Hist2D, self).__init__( params[0]['nbins'], array('d', params[0]['bins']), params[1]['nbins'], array('d', params[1]['bins']), name=name, title=title) self._post_init(**kwargs)
def sample (self, percent): """Sample the tags for a given percentage. Warning: the current object is changed! """ self.total = 0 for key in self._locations.keys(): plus = self._locations[key][0] plus_ind = self._indexes[key][0] total_plus = len(plus) num = int(total_plus*percent) ind_tokeep = sorted(random_sample(xrange(total_plus), num)) self._locations[key][0] = array(BYTE4, (plus[i] for i in ind_tokeep)) total_unique = 0 self._indexes[key][0] = array(BYTE4, []) pappend = self._indexes[key][0].append for i in ind_tokeep: pappend(plus_ind[i]) if plus_ind[i] == 0: total_unique += 1 minus = self._locations[key][1] minus_ind = self._indexes[key][1] total_minus = len(minus) num = int(total_minus*percent) ind_tokeep = sorted(random_sample(xrange(total_minus), num)) self._locations[key][1] = array(BYTE4, (minus[i] for i in ind_tokeep)) self._indexes[key][1] = array(BYTE4, []) mappend = self._indexes[key][1].append for i in ind_tokeep: mappend(minus_ind[i]) if minus_ind[i] == 0: total_unique += 1 self.total += total_unique
def remove_redundant (self): """Remove redundant position, keep the highest score. """ chrs = set(self._data.keys()) ndata = {} for chrom in chrs: ndata[chrom] = [array(BYTE4,[]),array(FBYTE4,[])] # for (pos,value) nd_p_append = ndata[chrom][0].append nd_s_append = ndata[chrom][1].append (p,s) = self._data[chrom] prev_p = None prev_s = None for i in xrange(len(p)): pi = p[i] si = s[i] if not prev_p: prev_p = pi prev_s = si else: if pi == prev_p: if si>prev_s: prev_s = si else: nd_p_append (prev_p) nd_s_append (prev_s) nd_p_append (prev_p) nd_s_append (prev_s) del self._data self._data = ndata
def getGenotypesForSubject(self, s, raw=False): """ Returns list of genotypes for all m markers for subject s. If raw==True, then an array of raw integer gcodes is returned instead """ if self._quick: nmarkers = len(self._markers) raw_array = array('i', [0]*nmarkers) seek_nibble = s % 4 for m in xrange(nmarkers): seek_byte = m * self._bytes_per_marker + s/4 + HEADER_LENGTH self._bedf.seek(seek_byte) geno = struct.unpack('B', self._bedf.read(1))[0] quartet = INT_TO_GCODE[geno] gcode = quartet[seek_nibble] raw_array[m] = gcode else: raw_array = array('i', [row[s] for row in self._genotypes]) if raw: return raw_array else: result = [] for m, gcode in enumerate(raw_array): result.append(self._marker_allele_lookup[m][gcode]) return result
def set_palette(name='default', ncontours=200): """Set a color palette from a given RGB list stops, red, green and blue should all be lists of the same length see set_decent_colors for an example""" if name == 'gray' or name == 'grayscale': stops = [0.00, 0.34, 0.61, 0.84, 1.00] red = [1.00, 0.84, 0.61, 0.34, 0.00] green = [1.00, 0.84, 0.61, 0.34, 0.00] blue = [1.00, 0.84, 0.61, 0.34, 0.00] # elif name == "whatever": # (define more palettes) elif name == 'brett': # brett palette print 'Setting palette to "Brett"' stops = [0.00, 0.05, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 0.95, 1.00] red = [0.00, 0.00, 0.05, 0.05, 0.10, 0.15, 0.70, 0.90, 1.00, 1.00, 1.00, 1.00, 0.51] green = [0.00, 0.00, 0.50, 0.50, 1.00, 0.90, 0.90, 0.90, 0.80, 0.60, 0.60, 0.00, 0.00] blue = [0.51, 1.00, 1.00, 0.60, 0.50, 0.30, 0.20, 0.15, 0.10, 0.05, 0.05, 0.00, 0.00] else: # default palette, looks cool stops = [0.00, 0.34, 0.61, 0.84, 1.00] red = [0.00, 0.00, 0.87, 1.00, 0.51] green = [0.00, 0.81, 1.00, 0.20, 0.00] blue = [0.51, 1.00, 0.12, 0.00, 0.00] s = array('d', stops) r = array('d', red) g = array('d', green) b = array('d', blue) npoints = len(s) TColor.CreateGradientColorTable(npoints, s, r, g, b, ncontours) gStyle.SetNumberContours(ncontours)
def setBrightness(brightness): global lastBrightness if (abs(brightness - lastBrightness) < 5): # if analog setting drifs a little, don't bother changing the brightness return lastBrightness = brightness if brightness > 255: brightness = 255 elif brightness < 0: brightness = 0 # for Sparkfun Serial backpack, brightness range is 128 to 157 if DISPLAY_TYPE == 'SPARKFUN': brightness = 128 + (brightness*29)/ 255 if Debug: print("setting brightness to " + str(brightness)) if DISPLAY_TYPE == 'MATRIX_ORBITAL': cmd = array.array('B', (COMMAND_PREFIX, 153, brightness)) elif DISPLAY_TYPE == 'SPARKFUN': cmd = array.array('B', (124, brightness)) else: cmd = array.array('B', (128, brightness)) writeToDisplay(cmd.tostring())
def setCursorPos(row, col, clearRow = False): """Position the LCD cursor - row and col are 1-based""" if clearRow and DISPLAY_TYPE != 'SPARKFUN': # clear the row by writing blanks to all columns in the row # move to start of row if DISPLAY_TYPE == 'MATRIX_ORBITAL': cmd = array.array('B', (COMMAND_PREFIX, 71, 1, row)) else: cmd = array.array('B', (COMMAND_PREFIX, 128, (row - 1) * numCols)) writeToDisplay(cmd.tostring()) writeToDisplay(' ' * numCols) if DISPLAY_TYPE == 'MATRIX_ORBITAL': cmd = array.array('B', (COMMAND_PREFIX, 71, col, row)) elif DISPLAY_TYPE == 'SPARKFUN': offset = 127 + col if row == 2: offset = 128 + 63 + col elif row == 3: offset = 128 + 19 + col elif row == 4: offset = 128 + 83 + col if Debug: print("setting cursor pos for Sparkfun " + str(offset)) cmd = array.array('B', (COMMAND_PREFIX, offset)) else: cmd = array.array('B', (COMMAND_PREFIX, 128, (row - 1) * numCols + col - 1)) writeToDisplay(cmd.tostring())
def __init__(self, width, height, texsize=128): self.umap = array('f', [0.0 for i in range(width * height)]) self.vmap = array('f', [0.0 for i in range(width * height)]) self.mask = array('B', [0 for i in range(width * height)]) self.width = width self.height = height self.texsize = texsize
def makeAutomat(mapping): """automat is array of integers (signed 16bits) on position 2*i is stored state transfer from state i if 0 is read on position 2*i+1 is stored transfer if 1 is read if transfer & 1 than transfer links to result array otherwise transfer>>1 is new state, transfers from new states are in automat on positions transfer and transfer+1 in results, the lies on positions transfer-1 and transfer """ automat=array('i',[-1,-1]) results=array('i') for bits, (d1,d2) in mapping.iteritems(): state=0 #make state transfer for all but last bit for bit in bits[:-1]: bit=int(bit) if automat[state|bit]==-1: automat[state|bit]=len(automat) automat.extend([-1,-1]) state=automat[state|bit] assert not state&1 #make last bit link to endstates table bit=int(bits[-1]) assert automat[state|bit]==-1 automat[state|bit]=len(results)|1 results.extend([d1,d2]) return automat, results
def getGenotypesByIndices(self, s, mlist, format): """ needed for grr if lped - deprecated but.. """ mlist = dict(zip(mlist,[True,]*len(mlist))) # hash quicker than 'in' ? raw_array = array('i', [row[s] for m,row in enumerate(self._genotypes) if mlist.get(m,None)]) if format == 'raw': return raw_array elif format == 'ref': result = array('i', [0]*len(mlist)) for m, gcode in enumerate(raw_array): if gcode == HOM0: nref = 3 elif gcode == HET: nref = 2 elif gcode == HOM1: nref = 1 else: nref = 0 result[m] = nref return result else: result = [] for m, gcode in enumerate(raw_array): result.append(self._marker_allele_lookup[m][gcode]) return result
def test_pack_into(self): test_string = b'Reykjavik rocks, eow!' writable_buf = array.array('b', b' '*100) fmt = '21s' s = struct.Struct(fmt) # Test without offset s.pack_into(writable_buf, 0, test_string) from_buf = writable_buf.tobytes()[:len(test_string)] self.assertEqual(from_buf, test_string) # Test with offset. s.pack_into(writable_buf, 10, test_string) from_buf = writable_buf.tobytes()[:len(test_string)+10] self.assertEqual(from_buf, test_string[:10] + test_string) # Go beyond boundaries. small_buf = array.array('b', b' '*10) self.assertRaises((ValueError, struct.error), s.pack_into, small_buf, 0, test_string) self.assertRaises((ValueError, struct.error), s.pack_into, small_buf, 2, test_string) # Test bogus offset (issue 3694) sb = small_buf self.assertRaises((TypeError, struct.error), struct.pack_into, b'', sb, None)
def __load_binary(data) : """Load binary graph as used by the cpp implementation of this algorithm """ if type(data) == types.StringType : data = open(data, "rb") reader = array.array("I") reader.fromfile(data, 1) num_nodes = reader.pop() reader = array.array("I") reader.fromfile(data, num_nodes) cum_deg = reader.tolist() num_links = reader.pop() reader = array.array("I") reader.fromfile(data, num_links) links = reader.tolist() graph = nx.Graph() graph.add_nodes_from(range(num_nodes)) prec_deg = 0 for index in range(num_nodes) : last_deg = cum_deg[index] neighbors = links[prec_deg:last_deg] graph.add_edges_from([(index, int(neigh)) for neigh in neighbors]) prec_deg = last_deg return graph
arreglo = [1, 2, 3] # equivalente a ArrayList de Java # En CPython ver implementacion: https://github.com/python/cpython/blob/master/Objects/listobject.c print(f"Id arreglo: {id(arreglo)} original") arreglo.append(1) # O(1) casi siempre. En caso de que se llene el arreglo y hacer realloc seria O(n) print(f"Id arreglo: {id(arreglo)} depués de append") arreglo+=[1] # no crea nuevo arreglo print(f"Id arreglo: {id(arreglo)} depués de concat") arr2 = [3, 4] print(f"Id arr2: {id(arr2)} original") print(f"Id arreglo+arr2: {id(arreglo+arr2)}") # crea nuevo arreglo print(f"Id arr2+arreglo: {id(arr2+arreglo)}") arreglo.insert(1, 2); # more i>0.... o sea O(n) arreglo.insert(2, 2); arreglo.insert(3, 2); # https://docs.python.org/3/library/array.html from array import array arr = array('l', [1, 2, 3, 4, 5]) arr.append(2) print(arr) for a in arr: print(a)
def test_gdal_contour_4(): if test_cli_utilities.get_gdal_contour_path() is None: return 'skip' try: os.remove('tmp/contour_orientation.shp') except: pass try: os.remove('tmp/contour_orientation.dbf') except: pass try: os.remove('tmp/contour_orientation.shx') except: pass drv = gdal.GetDriverByName('GTiff') wkt = 'GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9108\"]],AUTHORITY[\"EPSG\",\"4326\"]]' size = 160 precision = 1. / size ds = drv.Create('tmp/gdal_contour_orientation.tif', size, size, 1) ds.SetProjection( wkt ) ds.SetGeoTransform( [ 1, precision, 0, 50, 0, -precision ] ) # Make the elevation 15 for the whole image raw_data = array.array('h',[15 for i in range(int(size))]).tostring() for i in range(int(size)): ds.WriteRaster( 0, i, int(size), 1, raw_data, buf_type = gdal.GDT_Int16, band_list = [1] ) # Create a hill with elevation 25 raw_data = array.array('h',[25 for i in range(2)]).tostring() for i in range(2): ds.WriteRaster( int(size/4)+int(size/8)-1, i+int(size/2)-1, 2, 1, raw_data, buf_type = gdal.GDT_Int16, band_list = [1] ) # Create a depression with elevation 5 raw_data = array.array('h',[5 for i in range(2)]).tostring() for i in range(2): ds.WriteRaster( int(size/2)+int(size/8)-1, i+int(size/2)-1, 2, 1, raw_data, buf_type = gdal.GDT_Int16, band_list = [1] ) ds = None gdaltest.runexternal(test_cli_utilities.get_gdal_contour_path() + ' -a elev -i 10 tmp/gdal_contour_orientation.tif tmp/contour_orientation1.shp') ds = ogr.Open('tmp/contour_orientation1.shp') expected_contours = [ 'LINESTRING (1.621875 49.493749999999999,'+ '1.628125 49.493749999999999,'+ '1.63125 49.496875000000003,'+ '1.63125 49.503124999999997,'+ '1.628125 49.50625,'+ '1.621875 49.50625,'+ '1.61875 49.503124999999997,'+ '1.61875 49.496875000000003,'+ '1.621875 49.493749999999999)', 'LINESTRING (1.371875 49.493749999999999,'+ '1.36875 49.496875000000003,'+ '1.36875 49.503124999999997,'+ '1.371875 49.50625,'+ '1.378125 49.50625,'+ '1.38125 49.503124999999997,'+ '1.38125 49.496875000000003,'+ '1.378125 49.493749999999999,'+ '1.371875 49.493749999999999)' ] expected_elev = [ 10, 20 ] lyr = ds.ExecuteSQL("select * from contour_orientation1 order by elev asc") if lyr.GetFeatureCount() != len(expected_contours): print('Got %d features. Expected %d' % (lyr.GetFeatureCount(), len(expected_contours))) return 'fail' i = 0 test_failed = False feat = lyr.GetNextFeature() while feat is not None: expected_geom = ogr.CreateGeometryFromWkt(expected_contours[i]) if feat.GetField('elev') != expected_elev[i]: print('Got %f. Expected %f' % (feat.GetField('elev'), expected_elev[i])) return 'fail' if ogrtest.check_feature_geometry(feat, expected_geom) != 0: print('Got %s.\nExpected %s' % (feat.GetGeometryRef().ExportToWkt(),expected_contours[i])) test_failed = True i = i + 1 feat = lyr.GetNextFeature() ds.ReleaseResultSet(lyr) ds.Destroy() if test_failed: return 'fail' else: return 'success'
'uncerDn' : [0.0537,0.0667,0.0789,0.0920,0.1049,0.1189,0.133,0.1484], 'x_values': sqrts[1:], 'setup' : {'color': kAzure, 'linestyle': kSolid ,'linewidth': 2, 'fillstyle' : 3004, 'draw_opt' : "E2" }, 'legend' : {'text': "Standard model (m_{H} = 125 GeV, N^{3}LO gg#rightarrow H)", 'draw_opt' : 'fl'} }, } #create asymetric graphs from 'graphs' #v_data_hi_allunc = TVectorD(len(data_hi_allunc), array('d',[data_hi_allunc[i] for i in range(len(data_hi_allunc))])) #for gr in graphs_list.keys(): for gr_key, gr_setup in graphs_list.iteritems(): #create arrays from lists v_x_values = TVectorD(len(gr_setup['x_values']), array('d',[gr_setup['x_values'][i] for i in range(len(gr_setup['x_values']))])) if gr_key.startswith('model_dependancy'): v_x_valuesUp = v_x_valuesDn = TVectorD(len(gr_setup['x_values']), array('d',[0.2 for i in range(len(gr_setup['x_values']))])) else: v_x_valuesUp = v_x_valuesDn = TVectorD(len(gr_setup['x_values']), array('d',[0.0 for i in range(len(gr_setup['x_values']))])) v_central = TVectorD(len(gr_setup['central']), array('d',[gr_setup['central'][i] for i in range(len(gr_setup['central']))])) v_uncerUp = TVectorD(len(gr_setup['uncerUp']), array('d',[gr_setup['uncerUp'][i] for i in range(len(gr_setup['uncerUp']))])) v_uncerDn = TVectorD(len(gr_setup['uncerDn']), array('d',[gr_setup['uncerDn'][i] for i in range(len(gr_setup['uncerDn']))])) gr_setup['graph'] = TGraphAsymmErrors(v_x_values,v_central,v_x_valuesDn,v_x_valuesUp, v_uncerDn,v_uncerUp) if not gr_key.startswith("measured"): gr_setup['graph'].SetFillStyle(gr_setup['setup']['fillstyle']); gr_setup['graph'].SetFillColor(gr_setup['setup']['color']) gr_setup['graph'].SetLineColor(gr_setup['setup']['color']) #gr_setup['graph'].SetLineColor(kBlack) gr_setup['graph'].SetLineStyle(gr_setup['setup']['linestyle'])
def writeCktFile(self, filePath): rootObj = dict() numWires = len(self.wireList) nextCtrl = 0xFFFE # 'B' for unsigned integer, minimum of 1 byte wirePulled = array('B', [0] * numWires) # 'I' for unsigned int, minimum of 2 bytes wireControlFets = array('I') wireGates = array('I') numNoneWires = 0 wireNames = [] for i, wire in enumerate(self.wireList): if wire == None: wireControlFets.append(0) wireControlFets.append(nextCtrl) wireGates.append(0) wireGates.append(nextCtrl) numNoneWires += 1 wireNames.append('') continue wirePulled[i] = wire.pulled wireControlFets.append(len(wire.ins)) for transInd in wire.ins: wireControlFets.append(transInd) wireControlFets.append(nextCtrl) wireGates.append(len(wire.outs)) for transInd in wire.outs: wireGates.append(transInd) wireGates.append(nextCtrl) wireNames.append(wire.name) noWire = 0xFFFD numFets = len(self.transistorList) fetSide1WireInds = array('I', [noWire] * numFets) fetSide2WireInds = array('I', [noWire] * numFets) fetGateWireInds = array('I', [noWire] * numFets) for i, trans in enumerate(self.transistorList): if trans == None: continue fetSide1WireInds[i] = trans.c1 fetSide2WireInds[i] = trans.c2 fetGateWireInds[i] = trans.gate rootObj['NUM_WIRES'] = numWires rootObj['NEXT_CTRL'] = nextCtrl rootObj['NO_WIRE'] = noWire rootObj['WIRE_PULLED'] = wirePulled rootObj['WIRE_CTRL_FETS'] = wireControlFets rootObj['WIRE_GATES'] = wireGates rootObj['WIRE_NAMES'] = wireNames rootObj['NUM_FETS'] = numFets rootObj['FET_SIDE1_WIRE_INDS'] = fetSide1WireInds rootObj['FET_SIDE2_WIRE_INDS'] = fetSide2WireInds # Extra info to verify the data and connections rootObj['FET_GATE_INDS'] = fetGateWireInds rootObj['NUM_NULL_WIRES'] = numNoneWires of = open(filePath, 'wb') pickle.dump(rootObj, of) of.close()
def image_from_rgba_data(size, data_list): data = array('B', data_list).tobytes() image = Image.frombytes('RGBA', size, data) return image
def image_from_palette_data(size, data_list): data = array('B', data_list).tobytes() image = Image.frombytes('P', size, data) return image
def main(): f = open("baseline.result", "r") baselines = f.readlines() f.close() baselines = [line.split(",") for line in baselines] (nvar, tauc_avg, tauc_error) = zip(*baselines) nvar = [int(i) for i in nvar] tauc_avg = [float(i) for i in tauc_avg] tauc_error = [float(i) for i in tauc_error] max_n_var = len(nvar) leg = ROOT.TLegend(0.5, 0.2, 0.8, 0.35) leg.SetBorderSize(0) leg.SetFillColor(0) leg.SetTextSize(0.025) leg.SetTextFont(42) x = array.array('f', range(1, max_n_var + 1)) y = array.array('f', tauc_avg) ye = array.array('f', tauc_error) xe = array.array('f', [0] * max_n_var) gr = ROOT.TGraphErrors(max_n_var, x, y, xe, ye) gr.SetMarkerColor(38) gr.SetLineColor(38) gr.SetMarkerStyle(20) gr.SetTitle("ROC Integral vs No. of Variables") gr.GetXaxis().SetTitle("No. of Training Variables") gr.GetYaxis().SetTitle("Relative Performance (AUROC)") leg.AddEntry( gr, "#splitline{Reference Baseline}{(Randomly selected variable sets as basis of comparison)}", "p") f = open("roc-tmva.result", "r") lines = f.readlines() f.close() blabel = [float((l.split(",")[0]).split("-")[-1]) for l in lines] bdata = [float((l.split(",")[-1])) for l in lines] x2 = array.array('f', blabel) y2 = array.array('f', bdata) d = dict() gr4 = plot_file("roc-tmva.result", 813, 813) gr9 = plot_file("itrRm.result", 905, 905) c1 = ROOT.TCanvas( "c1", "Relative Performance (AUROC) vs No. of Training Variables", 950, 600) gr.Draw("APL") gr4.Draw("PL") leg.AddEntry( gr4, "#splitline{TMVA out-of-the-box Ranking}{(Performance of top N vars as ranked by TMVA)}", "p") leg.AddEntry( gr9, "#splitline{Iterative Removal - vSearch}{(Removing var with least impact on performance iteratively)}", "p") leg.Draw() print "press enter to continue\n" raw_input()
def test_hash_array(self): a = array.array("b", range(10)) for cons in self.hash_constructors: c = cons(a) c.hexdigest()
N = int(sys.argv[1]) except: N = 200 try: runs = int(sys.argv[2]) except: runs = 10 #sys.stdout = open("fourpeaks%d.txt" % N, "w") sys.stdout = open("fourpeaks.csv", "a") #N=200 T=int((N/5)*4) fill = [2] * N ranges = array('i', fill) iters = 500000 ef = FourPeaksEvaluationFunction(T) odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() df = DiscreteDependencyTree(.1, ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) t0 = time.time() calls = []
#!/usr/bin/python # -*- coding: utf-8 -*- # Python 2.x # a simple binary grep utility import os, glob, mmap, shutil, sys, array if len(sys.argv) != 2: print "usage: bgrep.py hex_string" print "example of hex_string: 001122aabb" exit(0) pattern = array.array('B', sys.argv[1].decode("hex")) for dir, subdir, files in os.walk(os.getcwd()): for file in files: try: fullfname = dir + "/" + file fp = open(fullfname, 'r+') if os.stat(fp.name).st_size > 0: #print ("processing %s" % fp.name) mm = mmap.mmap(fp.fileno(), os.stat(fp.name).st_size) if mm.find(pattern, 0) != -1: sys.stdout.write("[%s] pattern found\n" % fp.name) sys.stdout.flush() mm.close() except IOError: sys.stderr.write("%s: IOError\n" % fullfname)
def get_fiducial_histograms(source, obs, prods, add_stat_only=False, scaling={}): if '%s/fiducial' % confdir not in sys.path: sys.path.append('%s/fiducial' % confdir) from nuisances import nuisances nominals = {} for prod in prods: phist = source.Get('fiducial/%s/histo_%s' % (obs, prod)) try: phist.Scale(scaling[prod]) except KeyError: pass nominals[prod] = phist phist.SetDirectory(0) htotal = nominals[prods[0]].Clone('total_%s' % obs) htotal.SetDirectory(0) for prod in prods[1:]: htotal.Add(nominals[prod]) if add_stat_only: statonly = htotal.Clone() uncert = rnp.array(htotal.GetSumw2()) # stat uncert squared for nuis in nuisances.itervalues(): up = np.zeros_like(uncert) down = np.zeros_like(uncert) if nuis['type'] == 'shape': for prod in nuis['samples']: if prod not in prods: continue dup = rnp.hist2array(source.Get('fiducial/%s/histo_%s_%sUp' % (obs, prod, nuis['name'])), include_overflow=True, copy=False) ddown = rnp.hist2array(source.Get('fiducial/%s/histo_%s_%sDown' % (obs, prod, nuis['name'])), include_overflow=True, copy=False) try: dup *= scaling[prod] ddown *= scaling[prod] except KeyError: pass up += dup down += ddown elif nuis['type'] == 'lnN': for prod, value in nuis['samples'].iteritems(): if prod not in prods: continue nom = rnp.hist2array(nominals[prod], include_overflow=True, copy=False) if '/' in value: vdown, vup = map(float, value.split('/')) up += nom * vup down += nom * vdown else: value = float(value) up += nom * value down += nom / value up -= down up *= 0.5 uncert += np.square(up) htotal.GetSumw2().Set(len(uncert), array.array('d', uncert)) if add_stat_only: return nominals, htotal, statonly else: return nominals, htotal
def _add_rules(self, rules, _legalese=common_license_words, _spdx_tokens=frozenset()): """ Add a list of Rule objects to the index and constructs optimized and immutable index structures. `_legalese` is a set of common license-specific words aka. legalese `_spdx_tokens` is a set of token strings used in SPDX license identifiers """ if self.optimized: raise Exception('Index has been optimized and cannot be updated.') # initial dictionary mapping for known legalese tokens ######################################################################## # FIXME: we should start at 1, and ids are become valid unichr values self.dictionary = dictionary = { ts: tid for tid, ts in enumerate(sorted(_legalese))} dictionary_get = dictionary.get self.len_legalese = len_legalese = len(dictionary) highest_tid = len_legalese - 1 # Add SPDX key tokens to the dictionary # these are always treated as non-legalese. This may seem weird # but they are detected in expressions alright and some of their # tokens exist as rules too (e.g. GPL) ######################################################################## for sts in sorted(_spdx_tokens): stid = dictionary_get(sts) if stid is None: # we have a never yet seen token, so we assign a new tokenid highest_tid += 1 stid = highest_tid dictionary[sts] = stid self.rules_by_rid = rules_by_rid = list(rules) # ensure that rules are sorted rules_by_rid.sort() len_rules = len(rules_by_rid) # create index data structures # OPTIMIZATION: bind frequently used methods to the local scope for # index structures ######################################################################## tids_by_rid_append = self.tids_by_rid.append false_positive_rids_add = self.false_positive_rids.add regular_rids_add = self.regular_rids.add approx_matchable_rids_add = self.approx_matchable_rids.add # since we only use these for regular rules, these lists may be sparse. # their index is the rule rid self.high_postings_by_rid = high_postings_by_rid = [None] * len_rules self.sets_by_rid = sets_by_rid = [None] * len_rules self.msets_by_rid = msets_by_rid = [None] * len_rules # track all duplicate rules: fail and report dupes at once at the end dupe_rules_by_hash = defaultdict(list) rules_automaton_add = partial(match_aho.add_sequence, automaton=self.rules_automaton, with_duplicates=False) if USE_AHO_FRAGMENTS: fragments_automaton_add = partial( match_aho.add_sequence, automaton=self.fragments_automaton, with_duplicates=True, ) if USE_RULE_STARTS: starts_automaton_add_start = partial( match_aho.add_start, automaton=self.starts_automaton, ) # OPTIMIZED: bind frequently used objects to local scope rid_by_hash = self.rid_by_hash match_hash_index_hash = match_hash.index_hash match_set_tids_set_counter = match_set.tids_set_counter match_set_multiset_counter = match_set.multiset_counter len_starts = SMALL_RULE min_len_starts = SMALL_RULE * 6 ngram_len = AHO_FRAGMENTS_NGRAM_LEN # Index each rule ######################################################################## for rid, rule in enumerate(rules_by_rid): # assign rid rule.rid = rid rule_token_ids = array('h', []) tids_by_rid_append(rule_token_ids) # A rule is weak if it does not contain at least one legalese word: # we consider all rules to be weak until proven otherwise below. # "weak" rules can only be matched with an automaton. is_weak = True for rts in rule.tokens(): rtid = dictionary_get(rts) if rtid is None: # we have a never yet seen token, so we assign a new tokenid # note: we could use the length of the dictionary instead highest_tid += 1 rtid = highest_tid dictionary[rts] = rtid if is_weak and rtid < len_legalese: is_weak = False rule_token_ids.append(rtid) # build hashes index and check for duplicates rule texts rule_hash = match_hash_index_hash(rule_token_ids) dupe_rules_by_hash[rule_hash].append(rule) #################### # populate automaton with the whole rule tokens sequence, for all # RULEs, be they "standard"/regular, weak, false positive or small #################### rules_automaton_add(tids=rule_token_ids, rid=rid) if rule.is_false_positive: # False positive rules do not participate in the set or sequence # matching at all: they are used for exact matching and in post- # matching filtering false_positive_rids_add(rid) continue # from now on, we have regular rules rid_by_hash[rule_hash] = rid regular_rids_add(rid) # Some rules cannot be matched as a sequence are "weak" rules if not is_weak: approx_matchable_rids_add(rid) #################### # update high postings: positions by high tids used to # speed up sequence matching #################### # no postings for rules that cannot be matched as a sequence (too short and weak) # TODO: this could be optimized with a group_by postings = defaultdict(list) for pos, tid in enumerate(rule_token_ids): if tid < len_legalese: postings[tid].append(pos) # OPTIMIZED: for speed and memory: convert postings to arrays postings = {tid: array('h', value) for tid, value in postings.items()} high_postings_by_rid[rid] = postings #################### # ... and ngram fragments: compute ngrams and populate an automaton with ngrams #################### if (USE_AHO_FRAGMENTS and rule.minimum_coverage < 100 and rule.length > ngram_len ): all_ngrams = tokenize.ngrams(rule_token_ids, ngram_length=ngram_len) all_ngrams_with_pos = tokenize.select_ngrams(all_ngrams, with_pos=True) # all_ngrams_with_pos = enumerate(all_ngrams) for pos, ngram in all_ngrams_with_pos: fragments_automaton_add(tids=ngram, rid=rid, start=pos) #################### # use the start and end of this rule as a break point for query runs #################### if USE_RULE_STARTS and rule.length > min_len_starts: starts_automaton_add_start( tids=rule_token_ids[:len_starts], rule_identifier=rule.identifier, rule_length=rule.length, ) #################### # build sets and multisets indexes, for all regular rules as we need # the thresholds #################### tids_set, mset = match_set.build_set_and_mset( rule_token_ids, _use_bigrams=USE_BIGRAM_MULTISETS) sets_by_rid[rid] = tids_set msets_by_rid[rid] = mset #################################################################### #################################################################### # FIXME!!!!!!! we should store them: we need them and we recompute # them later at match time tids_set_high = match_set.high_tids_set_subset( tids_set, len_legalese) mset_high = match_set.high_multiset_subset( mset, len_legalese, _use_bigrams=USE_BIGRAM_MULTISETS) # FIXME!!!!!!! #################################################################### #################################################################### #################### # update rule thresholds #################### rule.length_unique = match_set_tids_set_counter(tids_set) rule.high_length_unique = match_set_tids_set_counter(tids_set_high) rule.high_length = match_set_multiset_counter(mset_high) rule.compute_thresholds() ######################################################################## # Finalize index data structures ######################################################################## # some tokens are made entirely of digits and these can create some # worst case behavior when there are long runs on these ######################################################################## self.digit_only_tids = intbitset([ i for i, s in enumerate(self.tokens_by_tid) if s.isdigit()]) # Create the tid -> token string lookup structure. ######################################################################## self.tokens_by_tid = tokens_by_tid = [ ts for ts, _tid in sorted(dictionary.items(), key=itemgetter(1))] self.len_tokens = len_tokens = len(tokens_by_tid) # Finalize automatons ######################################################################## self.rules_automaton.make_automaton() if USE_AHO_FRAGMENTS: self.fragments_automaton.make_automaton() if USE_RULE_STARTS: match_aho.finalize_starts(self.starts_automaton) ######################################################################## # Do some sanity checks ######################################################################## msg = 'Inconsistent structure lengths' assert len_tokens == highest_tid + 1 == len(dictionary), msg msg = 'Cannot support more than licensedcode.index.MAX_TOKENS: %d' % MAX_TOKENS assert len_tokens <= MAX_TOKENS, msg dupe_rules = [rules for rules in dupe_rules_by_hash.values() if len(rules) > 1] if dupe_rules: dupe_rule_paths = [ '\n'.join( sorted([ ('file://' + rule.text_file) if rule.text_file else ('text: ' + rule.stored_text) for rule in rules]) ) for rules in dupe_rules ] msg = ('Duplicate rules: \n' + '\n\n'.join(dupe_rule_paths)) raise AssertionError(msg) self.optimized = True
def __bytes__(self): return (bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))
def __out(self, string, filt): self._outp += array.array('B', re.sub(".*(" + filt + ").*\.\s*(\[.*\])?", "", string))
def TMVAReader (filenameSTRING,sigtreeSTRINGS,bkgtreeSTRING,variablesSTRING,varnames,varweightfiles,xmins,xmaxs): for sigtreeSTRING in sigtreeSTRINGS: inputfile = R.TFile(filenameSTRING,"read") reader = R.TMVA.Reader() signalhists = [] backgroundhists= [] for varname,xmin,xmax in zip(varnames,xmins,xmaxs): signalhist = R.TH1F("SignalHist" + varname+sigtreeSTRING,"Signal"+varname+sigtreeSTRING,60,xmin,xmax ) backgroundhist = R.TH1F("BackgroundHist Hist" + "Background"+ varname,varname,60,xmin,xmax) signalhists.append(signalhist) backgroundhists.append(backgroundhist) sigtree = inputfile.Get(sigtreeSTRING) bkgtree = inputfile.Get(bkgtreeSTRING) from array import array branchdict = {} for i in variablesSTRING: branchdict[i] = array('f',[0.]) reader.AddVariable(i,branchdict[i]) sigtree.SetBranchAddress(i,branchdict[i]) bkgtree.SetBranchAddress(i,branchdict[i]) for name,file in zip(varnames,varweightfiles): reader.BookMVA(name,file) i = 0 while sigtree.GetEntry(i): i += 1 for name,histo in zip(varnames,signalhists): classify = reader.EvaluateMVA(name) if i == 1: print(str(classify) + ' <<---Signal for ' + name) histo.Fill(classify) i = 0 while bkgtree.GetEntry(i): i +=1 for name,histo in zip(varnames,backgroundhists): classify = reader.EvaluateMVA(name) if i == 1: print(str(classify) + ' <<-- Background for ' + name) histo.Fill(classify) for histosig,histobkg,name in zip(signalhists,backgroundhists,varnames): canvas = R.TCanvas() histosig.SetStats(1) ymax = None if histosig.GetBinContent(histosig.GetMaximumBin()) > histobkg.GetBinContent(histobkg.GetMaximumBin()): ymax = histosig.GetBinContent(histosig.GetMaximumBin()) else: ymax = histobkg.GetBinContent(histobkg.GetMaximumBin()) histosig.GetYaxis().SetRangeUser(0,ymax*1.5) histosig.SetLineColor(R.kSpring-4) histosig.SetFillColor(R.kSpring-4) histosig.Draw("HIST") histobkg.Draw("HIST,same") histosig.Draw("Hist,same") R.gPad.RedrawAxis() canvas.Print(name+"_"+sigtreeSTRING+".png")
def __init__(self): self._lock = threading.Lock() self._cv = threading.Condition(self._lock) self._event = None self._buffer = array.array('B') self._closed = False
def read_ps4ds(jsdev): """ The Sony PlayStation 4 controller has fewer buttons. The throttles are analog (see axes) and binary (see buttons). Runs as a thread. axis 0: left stick X 1: left stick Y 2: left throttle 3: right stick X 4: right stick Y 5: right throttle 6: dPad X 7: dPad Y button 0: cross NS B 1: circle NS A 2: triangle NS X 3: square NS Y 4: left trigger NS left trigger 5: right trigger NS right trigger 6: left throttle NS left throttle 7: right throttle NS right throttle 8: share NS minus 9: options NS plus 10: logo NS home 11: left stick button NS left stick button 12: right stick button NS rgith stick button share options triangle square circle cross """ BUTTON_MAP = array.array('B', [ DS4Button.SQUARE, DS4Button.CROSS, DS4Button.CIRCLE, DS4Button.TRIANGLE, DS4Button.L1, DS4Button.R1, DS4Button.L2, DS4Button.R2, DS4Button.SHARE, DS4Button.OPTIONS, DS4Button.L3, DS4Button.R3, DS4Button.LOGO, DS4Button.TPAD]) while True: try: evbuf = jsdev.read(8) except: jsdev.close() break if evbuf: timestamp, value, type, number = unpack('IhBB', evbuf) if type == 0x01: # button event button_out = BUTTON_MAP[number] if value: DS4G.press(button_out) else: DS4G.release(button_out) if type == 0x02: # axis event axis = ((value + 32768) >> 8) # Axes 0,1 left stick X,Y if number == 0: DS4G.leftXAxis(axis) elif number == 1: DS4G.leftYAxis(axis) elif number == 2: DS4G.leftTrigger(axis) # Axes 3,4 right stick X,Y elif number == 3: DS4G.rightXAxis(axis) elif number == 4: DS4G.rightYAxis(axis) elif number == 5: DS4G.rightTrigger(axis) # Axes 6,7 directional pad X,Y elif number == 6: DS4G.dPadXAxis(axis) elif number == 7: DS4G.dPadYAxis(axis)
import ROOT from ROOT import * gROOT.SetBatch(True) gStyle.SetOptStat(0) gStyle.SetOptTitle(0) ROOT.gInterpreter.Declare( "#include \"MyTools/RootUtils/interface/SeabornInterface.h\"") ROOT.gInterpreter.Declare( "#include \"MyTools/RootUtils/interface/CanvasHelpers.h\"") gSystem.Load( "~/Dijets/CMSSW_7_4_15/lib/slc6_amd64_gcc491/libMyToolsRootUtils.so") seaborn = Root.SeabornInterface() seaborn.Initialize() Root.SetCanvasStyle() acceptance_mass_array = array( 'd', [1500., 1750., 2000., 2500., 3000., 4000., 5000.]) # acceptance_array = array('d', [0.085, 0.072, 0.035, 0.025, 0.021,]) # My old values, taken from the ATLAS tables acceptance_array = array('d', [ 0.0993114, 0.0857177, 0.0742023, 0.0398483, 0.0264772, 0.0173586, 0.00952033 ]) # Kirtimaan's values tg_acceptance = TGraph(len(acceptance_mass_array), acceptance_mass_array, acceptance_array) mass_array = array('d', [1250., 1500., 1750., 2000., 2500., 3000., 4000.]) # xs*BR*A values taken from digitizing the ATLAS plot # My values #xsBRAs = { # 1250.:0.04739380332427473, # 1500.:0.03107133633710692, # 1750.:0.04851860651757168,
print('---< about bytearray(python 2) >---') cafe_arr = bytearray(cafe) print('cafe_arr = {0}'.format(cafe_arr)) print('cafe_arr[0] = {0}'.format(cafe_arr[0])) print('cafe_arr[:1] = {0}'.format(cafe_arr[:1])) print() print('---< fromhex in binary sequence >---') print('bytes.fromhex("31 4B CE A9") = {0}'.format( bytes.fromhex('31 4B CE A9'))) print() print('---< Initialize bytes from raw array data. >---') numbers = array.array('h', [-2, -1, 0, 1, 2]) print('number(raw array) = \n{0}'.format(numbers)) octets = bytes(numbers) print('bytes(number) = {0}'.format(octets)) print() ''' ------------------------------------------------------------------------------------------------------------------------ struct and memory view struct is Interpret bytes as packed binary data. ------------------------------------------------------------------------------------------------------------------------ ''' print('--------------------------------------------\n' ' struct and memory view\n' '--------------------------------------------\n')
def read_hori_mini4(jsdev): """ The Hori Mini4 is a licensed PS4 compatible controller. The throttles are analog (see axes) and binary (see buttons). Runs as a thread. axis 0: left stick X 1: left stick Y 2: right stick X 3: left throttle 4: right throttle 5: right stick Y 6: dPad X 7: dPad Y button 0: cross 1: circle 2: triangle 3: square 4: L1 5: R1 6: L2 7: R2 8: share 9: options 10: logo 11: L3 12: R3 share options triangle square circle cross """ BUTTON_MAP = array.array('B', [ DS4Button.SQUARE, DS4Button.CROSS, DS4Button.CIRCLE, DS4Button.TRIANGLE, DS4Button.L1, DS4Button.R1, DS4Button.L2, DS4Button.R2, DS4Button.SHARE, DS4Button.OPTIONS, DS4Button.L3, DS4Button.R3, DS4Button.LOGO, DS4Button.TPAD]) while True: try: evbuf = jsdev.read(8) except: jsdev.close() break if evbuf: timestamp, value, type, number = unpack('IhBB', evbuf) if type == 0x01: # button event button_out = BUTTON_MAP[number] if value: DS4G.press(button_out) else: DS4G.release(button_out) if type == 0x02: # axis event axis = ((value + 32768) >> 8) # Axes 0,1 left stick X,Y if number == 0: DS4G.leftXAxis(axis) elif number == 1: DS4G.leftYAxis(axis) # Axes 2,3 right stick X,Y elif number == 2: DS4G.rightXAxis(axis) elif number == 3: DS4G.leftTrigger(axis) elif number == 4: DS4G.rightTrigger(axis) elif number == 5: DS4G.rightYAxis(axis) # Axes 6,7 directional pad X,Y elif number == 6: DS4G.dPadXAxis(axis) elif number == 7: DS4G.dPadYAxis(axis)
#weight residuals using errors weight = [] for i in range(len(dmb)): w = dmb[i] / sum(dmb) weight.append(w) #add scriptm to model scriptm = sum(residuals*weight) muModelData = muModelData + scriptm likeResiduals = np.matrix(mb - muModelData) #chi^2 likeValue = likeResiduals * np.linalg.inv(covarianceMatrix) * likeResiduals.getH() return likeValue #empty arrays to store results omegaMArr =arr.array('d', []) omegaLArr = arr.array('d', []) omegaKArr = arr.array('d', []) wAppend = arr.array('i', []) likeArray = arr.array('d', []) #for counting count = arr.array('i', []) count.append(0) def start(omegaMmin,omegaMmax,omegaLmin,omegaLmax,stepsize,iterations): c = 0 omegaM = random.uniform(omegaMmin,omegaMmax) omegaL = random.uniform(omegaLmin,omegaLmax) omegaK = 1 - omegaL - omegaM omegaMArr.append(round(omegaM,5)) omegaLArr.append(round(omegaL,5))
def construct_bst(preorder: array, start: Optional[int] = None, end: Optional[int] = None) -> Optional[Node]: """ BST: left - smaller than current right - bigger than current """ if start is None: start = 0 if end is None: end = len(preorder) - 1 if start > end: return None node = Node(preorder[start]) if start < end: index = start + 1 while index < end and preorder[index] < preorder[start]: index += 1 node.left = construct_bst(preorder, start + 1, index - 1) node.right = construct_bst(preorder, index, end) return node if __name__ == "__main__": inorder(construct_bst(array("I", [10, 5, 1, 7, 40, 50])))
def main(): parser = Parser( prog='spr2image', description='Default action is to convert a spr file to a gif.', epilog='example: spr2image bubble.spr => convert bubble.spr to bubble.gif' ) parser.add_argument( 'file', metavar='file.spr', action=ResolvePathAction ) parser.add_argument( '-d', metavar='file.gif', dest='dest', default=os.getcwd(), action=ResolvePathAction, help='image file to create' ) parser.add_argument( '-q', dest='quiet', action='store_true', help='quiet mode' ) parser.add_argument( '-v', '--version', dest='version', action='version', help=argparse.SUPPRESS, version=f'{parser.prog} version {qcli.__version__}' ) args = parser.parse_args() # Validate source file if not spr.is_sprfile(args.file): print(f'{parser.prog}: cannot find or open {args.file}', file=sys.stderr) sys.exit(1) # Validate or create out file if args.dest == os.getcwd(): image_path = os.path.dirname(args.file) image_name = os.path.basename(args.file).split('.')[0] + '.gif' args.dest = os.path.join(image_path, image_name) dest_dir = os.path.dirname(args.dest) or '.' if not os.path.exists(dest_dir): os.makedirs(dest_dir) image_filename = os.path.basename(args.dest) image_extension = image_filename.split('.')[-1] with spr.Spr.open(args.file) as spr_file: if not args.quiet: print(f'Converting: {os.path.basename(args.file)}') # Flatten out palette palette = [channel for rgb in vgio.quake.palette for channel in rgb] # Default frame animation is 10 frames per second default_duration = 10 / 60 * 1000 # Build a sequence of images from spr frames images = [] for frame in spr_file.frames: if frame.type == spr.SINGLE: size = frame.width, frame.height data = array.array('B', frame.pixels) img = Image.frombuffer('P', size, data, 'raw', 'P', 0, 1) img.putpalette(palette) images.append(img) else: print(f'{parser.prog}: frame groups are not supported', file=sys.stderr) sys.exit(1) # Save as gif if image_extension.upper() == 'GIF': first_frame = images[0] first_frame.putpalette(palette) remaining_frames = images[1:] first_frame.save( args.dest, save_all=True, append_images=remaining_frames, duration=default_duration, loop=0, optimize=False, #transparency=255, palette=palette ) else: image_directory = os.path.dirname(args.dest) image_name = image_filename.split('.')[0] for image_index, image in enumerate(images): filename = '{}_{}.{}'.format(image_name, image_index, image_extension) image.save( os.path.join(image_directory, filename), optimize=False, #transparency=255, palette=palette ) sys.exit(0)
print('Controller connected') jsdev = open(fn, 'rb') break # Get the device name. buf = bytearray(63) # buf = array.array('u', ['\0'] * 64) ioctl(jsdev, 0x80006a13 + (0x10000 * len(buf)), buf) # JSIOCGNAME(len) # Get rid of random padding buf = buf.rstrip(b'\0') js_name = str(buf, encoding='utf-8') print('Device name: %s' % js_name) # Get number of axes and buttons. buf = array.array('B', [0]) ioctl(jsdev, 0x80016a11, buf) # JSIOCGAXES num_axes = buf[0] buf = array.array('B', [0]) ioctl(jsdev, 0x80016a12, buf) # JSIOCGBUTTONS num_buttons = buf[0] # Get the axis map. buf = array.array('B', [0] * 0x40) ioctl(jsdev, 0x80406a32, buf) # JSIOCGAXMAP for axis in buf[:num_axes]: axis_name = axis_names.get(axis, 'unknown(0x%02x)' % axis) axis_map.append(axis_name) axis_states[axis_name] = 0.0
#All Values of same type #Arrays don't have specific type import array as arr #Alias vals = arr.array("i", [1, -2, 3]) # i -> typecode -> any number # b, B, u, h, H, i, I, l, L, q, Q, f or d # small case -> signed data type # upper case -> unsigned data type -> 0 to infinity print(vals) print(vals.buffer_info()) # (Address , size) vals.append(4) print(vals) print("--------------") print(vals[0]) print("-------------") for i in range(len(vals)): print(vals[i], end=" ") print() print("-------------")
import array import random import sys #read filenames from argv for filename in sys.argv[1:]: #create a random value matrix l = [random.randint(-100, 100) for i in xrange(64)] a = array.array('i', l) with open(filename, 'wb') as f: a.tofile(f) #print matrix info to cout l = [l[i:i + 8] for i in xrange(64) if i % 8 == 0] print "Write matrix into " + filename + ":" for i in xrange(8): print l[i] print
def main_part2(file_cfg): # time logging global start_time start_time = time.time() # param list: with open(file_cfg, "rb") as f: print("load configs from: " + file_cfg) config = pickle.load(f) seed_number = config.seed_number idx_gender = config.idx_gender idx_bg = config.idx_bg idx_fshape = config.idx_fshape idx_cloth = config.idx_cloth disp_bg = config.disp_bg # human data source: idx = config.idx_seq ishape = config.idx_ishape stride = config.stride from pickle import load import argparse log_message("input idx: %d" % idx) log_message("input ishape: %d" % ishape) log_message("input stride: %d" % stride) if idx == None: exit(1) if ishape == None: exit(1) if stride == None: log_message("WARNING: stride not specified, using default value 50") stride = 50 # import idx info (name, split) idx_info = load(open("pkl/idx_info.pickle", 'rb')) # get runpass (runpass, idx) = divmod(idx, len(idx_info)) log_message("start part 2") import hashlib import random # initialize random seeds with sequence id s = "synth_data:%d:%d:%d" % (idx, runpass, ishape) log_message("GENERATED SEED %d from string '%s'" % (seed_number, s)) random.seed(seed_number) np.random.seed(seed_number) # import configuration import config params = config.load_file('config', 'SYNTH_DATA') smpl_data_folder = params['smpl_data_folder'] smpl_data_filename = params['smpl_data_filename'] resy = params['resy'] resx = params['resx'] tmp_path = params['tmp_path'] output_path = params['output_path'] output_types = params['output_types'] stepsize = params['stepsize'] clipsize = params['clipsize'] openexr_py2_path = params['openexr_py2_path'] name = idx_info[idx]["name"] # compute number of cuts nb_ishape = max(1, int(np.ceil((idx_info[idx]['nb_frames'] - (clipsize - stride))/stride))) ishape = ishape%nb_ishape output_path = join(output_path, 'run%d' % runpass, name.replace(" ", "")) log_message("output path: " + output_path) tmp_path = join(tmp_path, 'run%d_%s_c%04d' % (runpass, name.replace(" ", ""), (ishape + 1))) # check whether openexr_py2_path is loaded from configuration file if 'openexr_py2_path' in locals() or 'openexr_py2_path' in globals(): for exr_path in openexr_py2_path.split(':'): sys.path.insert(1, exr_path) # to read exr imgs import OpenEXR import array import Imath log_message("Loading SMPL data") smpl_data = np.load(join(smpl_data_folder, smpl_data_filename)) cmu_parms, name = load_body_data(smpl_data, idx) res_paths = {k:join(tmp_path, '%05d_%s'%(idx, k)) for k in output_types if output_types[k]} data = cmu_parms[name] nframes = len(data['poses'][::stepsize]) # .mat files matfile_normal = join(output_path, name.replace(" ", "") + "_c%04d_normal.mat" % (ishape + 1)) matfile_gtflow = join(output_path, name.replace(" ", "") + "_c%04d_gtflow.mat" % (ishape + 1)) matfile_depth = join(output_path, name.replace(" ", "") + "_c%04d_depth.mat" % (ishape + 1)) matfile_segm = join(output_path, name.replace(" ", "") + "_c%04d_segm.mat" % (ishape + 1)) dict_normal = {} dict_gtflow = {} dict_depth = {} dict_segm = {} get_real_frame = lambda ifr: ifr FLOAT = Imath.PixelType(Imath.PixelType.FLOAT) # overlap determined by stride (# subsampled frames to skip) fbegin = ishape*stepsize*stride fend = min(ishape*stepsize*stride + stepsize*clipsize, len(data['poses'])) # LOOP OVER FRAMES for seq_frame, (pose, trans) in enumerate(zip(data['poses'][fbegin:fend:stepsize], data['trans'][fbegin:fend:stepsize])): iframe = seq_frame log_message("Processing frame %d" % iframe) for k, folder in res_paths.items(): if not k== 'vblur' and not k=='fg': for ii in range(2): path = join(folder, 'Image%04d_%d.exr' % (get_real_frame(seq_frame), ii)) exr_file = OpenEXR.InputFile(path) if k == 'normal': mat = np.transpose(np.reshape([array.array('f', exr_file.channel(Chan, FLOAT)).tolist() for Chan in ("R", "G", "B")], (3, resx, resy)), (1, 2, 0)) dict_normal['normal_%04d_%01d' % (iframe + 1, ii+1)] = mat.astype(np.float32, copy=False) # +1 for the 1-indexing elif k == 'gtflow': mat = np.transpose(np.reshape([array.array('f', exr_file.channel(Chan, FLOAT)).tolist() for Chan in ("R", "G")], (2, resx, resy)), (1, 2, 0)) dict_gtflow['gtflow_%04d_%01d' % (iframe + 1, ii+1)] = mat.astype(np.float32, copy=False) elif k == 'depth': mat = np.reshape([array.array('f', exr_file.channel(Chan, FLOAT)).tolist() for Chan in ("R")], (resx, resy)) dict_depth['depth_%04d_%01d' % (iframe + 1, ii+1)] = mat.astype(np.float32, copy=False) elif k == 'segm': mat = np.reshape([array.array('f', exr_file.channel(Chan, FLOAT)).tolist() for Chan in ("R")], (resx, resy)) dict_segm['segm_%04dd_%01d' % (iframe + 1, ii+1)] = mat.astype(np.uint8, copy=False) # remove(path) print("render infos: ") print(res_paths) print("#normal: %d"%(len(dict_normal.keys()))) print("#depth: %d"%(len(dict_depth.keys()))) print("#segm: %d"%(len(dict_segm.keys()))) import scipy.io scipy.io.savemat(matfile_normal, dict_normal, do_compression=True) scipy.io.savemat(matfile_gtflow, dict_gtflow, do_compression=True) scipy.io.savemat(matfile_depth, dict_depth, do_compression=True) scipy.io.savemat(matfile_segm, dict_segm, do_compression=True) # cleaning up tmp if tmp_path != "" and tmp_path != "/": log_message("Cleaning up tmp") os.system('rm -rf %s' % tmp_path) log_message("Completed batch")
def test_gdal_contour_1(): if test_cli_utilities.get_gdal_contour_path() is None: pytest.skip() try: os.remove('tmp/contour.shp') except OSError: pass try: os.remove('tmp/contour.dbf') except OSError: pass try: os.remove('tmp/contour.shx') except OSError: pass drv = gdal.GetDriverByName('GTiff') sr = osr.SpatialReference() sr.ImportFromEPSG(4326) wkt = sr.ExportToWkt() size = 160 precision = 1. / size ds = drv.Create('tmp/gdal_contour.tif', size, size, 1) ds.SetProjection(wkt) ds.SetGeoTransform([1, precision, 0, 50, 0, -precision]) raw_data = array.array('h', [10 for i in range(int(size / 2))]).tostring() for i in range(int(size / 2)): ds.WriteRaster(int(size / 4), i + int(size / 4), int(size / 2), 1, raw_data, buf_type=gdal.GDT_Int16, band_list=[1]) raw_data = array.array('h', [20 for i in range(int(size / 2))]).tostring() for i in range(int(size / 4)): ds.WriteRaster(int(size / 4) + int(size / 8), i + int(size / 4) + int(size / 8), int(size / 4), 1, raw_data, buf_type=gdal.GDT_Int16, band_list=[1]) raw_data = array.array('h', [25 for i in range(int(size / 4))]).tostring() for i in range(int(size / 8)): ds.WriteRaster(int(size / 4) + int(size / 8) + int(size / 16), i + int(size / 4) + int(size / 8) + int(size / 16), int(size / 8), 1, raw_data, buf_type=gdal.GDT_Int16, band_list=[1]) ds = None (_, err) = gdaltest.runexternal_out_and_err( test_cli_utilities.get_gdal_contour_path() + ' -a elev -i 10 tmp/gdal_contour.tif tmp/contour.shp') assert (err is None or err == ''), 'got error/warning' ds = ogr.Open('tmp/contour.shp') expected_envelopes = [[1.25, 1.75, 49.25, 49.75], [ 1.25 + 0.125, 1.75 - 0.125, 49.25 + 0.125, 49.75 - 0.125 ]] expected_height = [10, 20] lyr = ds.ExecuteSQL("select * from contour order by elev asc") assert lyr.GetSpatialRef().ExportToWkt( ) == wkt, 'Did not get expected spatial ref' assert lyr.GetFeatureCount() == len(expected_envelopes) i = 0 feat = lyr.GetNextFeature() while feat is not None: envelope = feat.GetGeometryRef().GetEnvelope() assert feat.GetField('elev') == expected_height[i] for j in range(4): if expected_envelopes[i][j] != pytest.approx( envelope[j], abs=precision / 2 * 1.001): print('i=%d, wkt=%s' % (i, feat.GetGeometryRef().ExportToWkt())) print(feat.GetGeometryRef().GetEnvelope()) pytest.fail( '%f, %f' % (expected_envelopes[i][j] - envelope[j], precision / 2)) i = i + 1 feat = lyr.GetNextFeature() ds.ReleaseResultSet(lyr) ds.Destroy()
def string2bits(bit_str: str) -> array.array: return array.array("B", map(int, bit_str))
rscale = 1. with open(cardpath) as datacard: lines = datacard.read().strip().split('\n') matches = re.match('# R x ([0-9.e+-]+)', lines[-1]) if matches: rscale = float(matches.group(1)) if rscale == 1.: sys.exit(0) shutil.copyfile(sourcepath, 'limittmp.root') variables = { 'limit': array.array('d', [0.]), 'limitErr': array.array('d', [0.]), 'mh': array.array('d', [0.]), 'syst': array.array('i', [0]), 'iToy': array.array('i', [0]), 'iSeed': array.array('i', [0]), 'iChannel': array.array('i', [0]), 't_cpu': array.array('f', [0.]), 't_real': array.array('f', [0.]), 'quantileExpected': array.array('f', [0.]) } source = ROOT.TFile.Open(sourcepath) output = ROOT.TFile.Open('limittmp.root', 'update')