def compile(self, path, module_name, output=None, allow_caching=True): if output == None: output = module_name output_path = os.path.join(self.destdir, output + ".bc") print "M", module_name if allow_caching: try: output_modified = os.path.getmtime(output_path) input_modified = os.path.getmtime(path) if input_modified <= output_modified: return except (OSError, IOError): pass data = open(path, "r").read() compiled = ir.execute(data) self.scan_imports(module_name, compiled) serialized = serialize.serialize(compiled, filename=path) output = open(output_path, "w") output.write(serialized) output.close()
def replace(infile, backupFile, overwrite=False): # Back up the existing database backup = serialize.serialize(outfile=backupFile, overwrite=overwrite) if not backup: print "Database replace cancelled due to failed backup." return False command = "mysql -u {} -p{} {} < {}".format(md_utils.config["db_user"], md_utils.config["db_password"], md_utils.config["db_database"], infile) proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) error = proc.communicate()[1].strip() # Ignore MySQL 'errors' given when the operation was successful # (e.g. the one about passwords over command line), but print errors if the operation failed. if proc.returncode != 0: print "The following error occurred while replacing the database:\n%s" % error else: print "Successfully replaced database from '%s'" % infile
def test013(_): e1 = Kanj(txt='田中さん', kanj=2, entr=555) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.entr, e2.entr) _.assertEqual(e1.kanj, e2.kanj) _.assertEqual(e1.txt, e2.txt)
def test014(_): e1 = Sens(notes='abcd', sens=2, entr=555) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.entr, e2.entr) _.assertEqual(e1.sens, e2.sens) _.assertEqual(e1.notes, e2.notes)
def send(self, cmd, *args): try: self._sock.send(serialize(cmd, *args)) except socket.error as e: if (e.errno == socket.errno.EPIPE): print("Broken pipe.") sys.exit(0)
def test012(_): e1 = Rdng(txt='あいうえお', rdng=2, entr=555) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.entr, e2.entr) _.assertEqual(e1.rdng, e2.rdng) _.assertEqual(e1.txt, e2.txt)
def test002(_): e1 = DbRow([555, 222, 2], ['id', 'seq', 'stat']) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.id, e2.id) _.assertEqual(e1.seq, e2.seq) _.assertEqual(e1.stat, e2.stat)
def test001(_): e1 = Obj(id=555, seq=222, stat=2) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.id, e2.id) _.assertEqual(e1.seq, e2.seq) _.assertEqual(e1.stat, e2.stat)
def compile(self, path, module_name, output=None, allow_caching=True): if output == None: output = module_name output_path = os.path.join(self.destdir, output + '.bc') print 'M', module_name if allow_caching: try: output_modified = os.path.getmtime(output_path) input_modified = os.path.getmtime(path) if input_modified <= output_modified: return except (OSError, IOError): pass data = open(path, 'r').read() compiled = ir.execute(data) self.scan_imports(module_name, compiled) serialized = serialize.serialize(compiled, filename=path) output = open(output_path, 'w') output.write(serialized) output.close()
def test001(_): a = [3, 4, 5] b = jdb.Obj(x=a, y=a) b2 = serialize.unserialize(serialize.serialize(b)) _.assertEqual(a, b2.x) _.assertEqual(b2.x, b2.y) _.assertEqual(id(b2.x), id(b2.y))
def test015(_): e1 = Gloss(txt='abcd', sens=2, gloss=3, entr=555, lang=33) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.entr, e2.entr) _.assertEqual(e1.sens, e2.sens) _.assertEqual(e1.gloss, e2.gloss) _.assertEqual(e1.lang, e2.lang)
def test002(_): a1 = [3, 4, 5] a2 = [3, 4, 5] b = jdb.Obj(x=a1, y=a2) b2 = serialize.unserialize(serialize.serialize(b)) _.assertEqual(a1, b2.x) _.assertEqual(b2.x, b2.y) _.assertNotEqual(id(b2.x), id(b2.y))
def export_execute(self, tid, e_str): """ Executes e_str in the context of the globals and locals from the execution frame in the specified thread. """ t_obj = self._debugger.get_thread(tid) result = t_obj.execute(e_str) return serialize.serialize(e_str, e_str, result)
def savePressed(self): filetypes = [('ttt files', '.ttt'), ('all files', '.*')] filename = tkFileDialog.asksaveasfilename(initialfile="savefile.ttt", filetypes=filetypes) if filename == "": return file = open(filename, "w") file.write(serialize(self.state)) file.close()
def test011(_): e1 = Entr(id=555, seq=222, stat=2) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(type(e1), type(e2)) _.assertEqual(e1.id, e2.id) _.assertEqual(e1.seq, e2.seq) _.assertEqual(e1.stat, e2.stat) _.assertEqual(e1.unap, e2.unap) _.assertEqual(e1.notes, e2.notes)
def register(): if request.method=='GET': return render_template("register.html") else: name=request.form.get("name") course=request.form.get("course") teacher= Teacher(name, course) session["teacher"]=serialize(teacher) return redirect(url_for("index"))
def recommend(): # print(request) obj = request.json print(str(obj['title'])) ans = get_recommendations(str(obj['title'])) ans2 = serialize(ans) return (jsonify(ans2))
def send_ack(self): if not self.socket or self.ack_sent: return False sdata = serialize(self.acks) sendmsg = mlprotocol.create_message(sdata) self.socket.send(sendmsg) self.ack_sent = True return True
def add(): if request.method=='GET': return render_template("add.html") else: id = request.form.get("id") firstname = request.form.get("firstname") lastname = request.form.get("lastname") gender = request.form.get("gender") teacher = retrieve_teacher() teacher.students[id] = Student(id, firstname, lastname, gender) session['teacher'] = serialize(teacher) return redirect(url_for("show_students"))
def edit(id): teacher = retrieve_teacher() student = teacher.students.pop(id) if request.method == 'GET': return render_template("edit.html", student=student) else: student.first_name = request.form.get("firstname") student.last_name = request.form.get("lastname") student.gender = request.form.get("gender") teacher.students[id] = student session['teacher'] = serialize(teacher) return redirect(url_for("show_students"))
def test_serialize_flat_dict(self): f_dict = {'a': 'First','b': 'Second','c': 'Third'} res = serialize.serialize('f', 'f', f_dict) self.assertEquals(res['name'], 'f') self.assertTrue(res['has_childs']) self.assertEquals(res['type'], 'dict') self.assertEquals(len(res['childs']), 3) # Check the first child f_child = res['childs'][0] self.assertEquals(f_child['type'], 'str')
def test_serialize_flat_dict(self): f_dict = {'a': 'First', 'b': 'Second', 'c': 'Third'} res = serialize.serialize('f', 'f', f_dict) self.assertEquals(res['name'], 'f') self.assertTrue(res['has_childs']) self.assertEquals(res['type'], 'dict') self.assertEquals(len(res['childs']), 3) # Check the first child f_child = res['childs'][0] self.assertEquals(f_child['type'], 'str')
def main(): workingtime = 0 programs = deserialize.deserialize() mylib = windll.LoadLibrary("main.dll") mylib.getProcessName.restype = c_char_p while True: if workingtime % 600 == 0: serialize.serialize(programs) response = mylib.getProcessName() name = response.decode('utf-8') if name == "error": continue if programs.get(name) != None: programs[name] = programs[name] + 5 time.sleep(5) workingtime += 5 else: programs[name] = 5 time.sleep(5) workingtime += 5
def test_serialize_deep_dict(self): d_dict = { 'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]} res = serialize.serialize('d', 'd', d_dict, 2) self.assertEquals(res['name'], 'd') self.assertTrue(res['has_childs']) self.assertEquals(len(res['childs']), 3) # Check the first child f_child = res['childs'][0] self.assertTrue(f_child['has_childs']) self.assertEquals(f_child['type'], 'list') self.assertEquals(len(f_child['childs']), 3)
def invoke(self, repopath, data): data = urllib.unquote_plus(data) method, cls, params = self._parse_params(data) try: if method == 'ping': return 'PONG' elif method == 'get_implementation_info': info = helpers.get_implementation_info(repopath) s_info = serialize(info) return s_info else: return self._invoke(repopath, method, cls, params) except Exception, e: info = { '__error__': helpers.get_error_info(e) } s_info = serialize(info) s_info = urllib.quote_plus(s_info) return s_info
def test_serialize_deep_dict(self): d_dict = {'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]} res = serialize.serialize('d', 'd', d_dict, 2) self.assertEquals(res['name'], 'd') self.assertTrue(res['has_childs']) self.assertEquals(len(res['childs']), 3) # Check the first child f_child = res['childs'][0] self.assertTrue(f_child['has_childs']) self.assertEquals(f_child['type'], 'list') self.assertEquals(len(f_child['childs']), 3)
def log(self, operation, transactionid=None): """transactionid of None means no transaction: immediate.""" file = self.file if file is None: self.restart() file = self.file verbose = self.verbose serial = serialize.serialize(operation) data = (transactionid, serial) if verbose: print id(self), "logging:", transactionid print operation checksum_dump(data, file) self.dirty = 1
def test101(_): e1 = Entr(id=555, seq=222, stat=2, _rdng=[Rdng(txt='あいうえお'), Rdng(txt='たちつてと')], _kanj=[Kanj(txt='田中さん')], _sens=[ Sens(_gloss=[Gloss(txt='abcd')]), Sens(_gloss=[Gloss( txt='abcd'), Gloss(txt='efg')]) ]) e2 = serialize.unserialize(serialize.serialize(e1)) _.assertEqual(e1, e2) _.assertEqual(e1._rdng[1].txt, e2._rdng[1].txt) _.assertEqual(e1._sens[1]._gloss[1].txt, e2._sens[1]._gloss[1].txt)
def _invoke(self, repopath, method, cls, params): dp = self.dp dp.reset_ack() if (not self.usercls and not self.userobj) or method != self.last_method: self.usercls = helpers.find_implementation(repopath, cls) self.userobj = self.usercls(data_provider = dp) self.last_method = method helpers.attach_parameters(dp, params) invoke_method(self.userobj, method, params) acks = dp.get_acks() s_acks = serialize(acks) s_acks = urllib.quote_plus(s_acks) return s_acks
def server_handler(self): # Wait for the user to tell us to listen while self.should_stop != True: # Loop until the user specified a listener while (len(bound_socks) == 0 and self.should_stop != True): sleep(5) try: listen_ready, send_ready, except_ready = select.select(listen_socks, send_socks, [], 5.0) except OSError as e: # Cntl-C before a listener if self.should_stop == True: break # Iterate through all of the sockets that have data waiting for sock in listen_ready: alias = host_list.get_alias(sock) host = host_list.hosts[alias] # If socket has data waiting and is one of the bound sockets, accept connection if sock in bound_socks: (client_socket, host_info) = sock.accept() #print(f"Connection from {host_info}") host_list.hosts[alias].client_sock = client_socket host_list.hosts[alias].status = 1 # Add our new client socket to select lists to watch for data listen_socks.append(client_socket) else: data = recv_data(sock) host.add_job(data) for sock in send_socks: alias = host_list.get_alias(sock) host = host_list.hosts[alias] #Might want to move serialization to main thread for speed down the road while len(host.send_queue): job = host.send_queue.pop() data = serialize(job) send_data(host.client_sock, data) send_socks.remove(host.client_sock)
def rt(_, seq): # Test round trip from entry object through # serialize.serialize, serialize.unserialize, back to # object. Compare input and output objects # by converting both to xml and comparing # text. (Watch out for order problems). # FIXME: reading database to slow, too volatile. # read from a test xml file instead. if not Cursor: globalSetup() # FIXME: don't hardwire corpus (aka src). sql = "SELECT id FROM entr WHERE seq=%s AND src=1" elist, r = jdb.entrList(Cursor, sql, [seq], ret_tuple=1) e1 = elist[0] jdb.augment_xrefs(Cursor, r['xref']) s = serialize.serialize(e1) e2 = serialize.unserialize(s) f1 = fmtxml.entr(e1) _.assert_(len(f1) > 40) # Sanity check to detect empty entry. f2 = fmtxml.entr(e2) _.assertEqual(f1, f2)
def load_and_preprocess(y_data_file='data/y_11.csv'): data, new_metadata, new_titles = load_aggregate_data() data, new_titles = transform_data(data, new_metadata, new_titles) y = load_y(y_data_file) original_len = len(y) data, y = group_by_time_period(data, new_titles, y) print "Grouped from {} down to {} rows.".format(original_len, len(y)) # with open('data/test1.csv', 'w') as f: # writer = csv.writer(f, delimiter = ',') # writer.writerow(new_titles) # writer.writerows(data) data = np.array(data) y_data = np.array(y) group_by_feature_index = new_titles.index('Group by qtt since beginning') max_group_by_feature_value = int(np.max(data[:, group_by_feature_index])) import serialize serialized_data = serialize.serialize( data, y_data, new_titles.index('individual-local-identifier'), group_by_feature_index, max_group_by_feature_value) X, y = serialize.flatten_chunk(serialized_data, new_titles, time_period=3) X = normalize(X, -1) # count = 0 # for i, value in enumerate(y[:-1]): # if value == y[i +1]: # count += 1 # print float(count) / len(y) print y[0] sklearn_utils.shuffle(X, y) return X, y, new_titles
def test_serialize_object(self): class _TestObject(object): """Class object to test serialization of object types.""" def __init__(self): """Testing method.""" self._attr = "a" def un_metodo(self, unarg = None): """Testing method.""" return "Hola" + self._attr + repr(unarg) def otro_metodo(self): """Testing method.""" return "Chau" + self._attr c_obj = _TestObject() res = serialize.serialize('c', 'c', c_obj) self.assertEquals(res['name'], 'c') self.assertTrue(res['has_childs']) self.assertEquals(res['type'], '_TestObject') # Check the first child f_child = res['childs'][0] self.assertEquals(f_child['type'], 'instancemethod')
def test_serialize_object(self): class _TestObject(object): """Class object to test serialization of object types.""" def __init__(self): """Testing method.""" self._attr = "a" def un_metodo(self, unarg=None): """Testing method.""" return "Hola" + self._attr + repr(unarg) def otro_metodo(self): """Testing method.""" return "Chau" + self._attr c_obj = _TestObject() res = serialize.serialize('c', 'c', c_obj) self.assertEquals(res['name'], 'c') self.assertTrue(res['has_childs']) self.assertEquals(res['type'], '_TestObject') # Check the first child f_child = res['childs'][0] self.assertEquals(f_child['type'], 'instancemethod')
def serve_forever(self): '''listen for incoming (serialized) initial ChromaPhotonLists, propagate photons in chroma, and reply with final photon list ''' while True: msg = self.socket.recv(copy=False) # parse ChromaPhotonList cpl = serialize.deserialize(msg.bytes) if not cpl: print 'Error deserializing message data' continue photons_in = photons.photons_from_cpl(cpl) print 'processing', len(photons_in), 'photons' # propagate photons in chroma simulation event = self.sim.simulate(photons_in, keep_photons_end=True).next() # return final (detected) photons to client photons_out = event.photons_end cpl = photons.cpl_from_photons(photons_out, process_mask=SURFACE_DETECT, detector=self.detector) msg = serialize.serialize(cpl) self.socket.send(msg)
#toprocess = ['test'] Construct.generateParam(True) fout = None for this_file in toprocess: print "processing: ", this_file cnt = 1 if fout != None: fout.close() fout = None sampleid = 0 fin1 = open('raw_data/'+ this_file + '.txt') while True: sentence_A = fin1.readline().strip().lower() if (not sentence_A): print cnt - 1 fin1.close() break sen_A = sentence_A.split() layers = Construct.lstm(sen_A) serialize.serialize(layers, 'nets/net_'+this_file+'/'+str(cnt - 1)) if cnt % 100 == 0: print cnt cnt += 1
for nidx in xrange(lSTree - lSOStr): node[nidx + lSOStr] = Token.token('n' + str(nidx), bidx_encoding, int(STree[nidx + lSOStr]) - 1, flag[int(STree[nidx + lSOStr]) - 1]) flag[int(STree[nidx + lSOStr]) - 1] = 1 node[lSTree - 1].parent = None #for nidx in xrange(len(node)): # print 'word: ' + node[nidx].word + ' bidx: ' + str (node[nidx].bidx) + ' parent: ' + str(node[nidx].parent) + ' pos: ' + str(node[nidx].pos) p_nodes = node Layers = InitByNodes(p_nodes) #fout = open('../../network1_' + config + '/' + str(n), 'wb') serialize.serialize(Layers, '../../network_pretrain_' + config + '/' + str(n)) #fout.close() n = n + 1 line1 = f1.readline() line2 = f2.readline() f1.close() f2.close() config = 'CV' f1 = open('TreeStructure/SOStr_' + config + '.txt') f2 = open('TreeStructure/STree_' + config + '.txt') #f1 = open('TreeStructure/SOS.txt') #f2 = open('TreeStructure/STree.txt') n = 0
#!/usr/bin/python # -*- coding: UTF-8 -*- # 整体策略说明 # - 对同一语言,从本地各仓库获取最新 merge 的项目为 v1.json,从 crowdIn 中获取的项目 # 为 v2 # - 序列化 v1.json 和 v2.json # - 以 v1.json 作为基础,比较 v1.json 和 v2.json, # * 改动的:使用 v2 文件 # * 相同的:跳过 # * 新增的:跳过 # - 获取新的结果 result,并进行反序列化 # - 将反序列化的内容,输出到文件中,作为该翻译语种的最终版本 result.json import serialize as sl v1 = sl.serialize('v1.json') v2 = sl.serialize('v2.json') result = sl.deserialize(sl.compare(v1, v2)) sl.write_to_file('./result.json', result)
def run(hostname, calculations=False, backtest=False, portfolio_manager=False, port=consts.PORT): from socket import socket, AF_INET, SOCK_STREAM from dataproviders import ClientDataProvider # import inspect import json # frm = inspect.stack()[1] # mod = inspect.getmodule(frm[0]) # filepath = os.path.dirname(os.path.abspath(mod.__file__)) projpath = os.getcwd() s = socket(AF_INET, SOCK_STREAM) s.connect((hostname, port)) atexit.register(close_socket_connection, s) "signal to start execution" sendmsg = mlprotocol.create_message( json.dumps({"calculations": calculations, "backtest": backtest, "portfolio_manager": portfolio_manager}) ) s.send(sendmsg) userobj = None socket_dataprovider = ClientDataProvider(socket=s) "receive data" while True: data = mlprotocol.get_message(s) # data = s.recv(consts.BUFFER_SIZE) if data == consts.STOP_FLAG: print "STOPPED" break socket_dataprovider.reset_ack() params = deserialize(data, dotted=True) invocation = params.get("_invocation") method = invocation["method"] cls = invocation["class"] if method == "ping": return "PONG" elif method == "get_implementation_info": info = helpers.get_implementation_info(projpath) s_info = serialize(info) socket_dataprovider.ack_data(s_info) socket_dataprovider.send_ack() continue if not userobj: usercls = helpers.find_implementation(projpath, cls) userobj = usercls(data_provider=socket_dataprovider) helpers.attach_parameters(socket_dataprovider, params) invoke_method(userobj, method, params) "send acknowledgement to the server" socket_dataprovider.send_ack()
def push(self, queue, msg): self._conn.rpush(queue, serialize(msg))
def pushleft(self, queue, msg): self._conn.lpush(queue, serialize(msg))
day_start = datetime.now(TZ).replace(hour=0, minute=0, second=0, microsecond=0) day_end = datetime.now(TZ).replace(hour=23, minute=59, second=59, microsecond=999999) client = caldav.DAVClient(CALDAV_URL, username=CALDAV_USER, password=CALDAV_PASSWORD) principal = caldav.Principal(client, CALDAV_URL) LOG.info([cal.name for cal in principal.calendars()]) todays_events = (cal.date_search(start=day_start, end=day_end) for cal in principal.calendars() if filter_fn(cal.name)) combined_cal = vobject.iCalendar() vevents = [ event.vobject_instance.vevent for event in itertools.chain(*todays_events) ] combined_cal.contents["vevent"] = vevents return combined_cal if __name__ == "__main__": calendar = caldav_today() formatted_events = [ calendar_tools.format_event(event) for event in calendar.components() ] print(serialize.serialize({"events": formatted_events}))
def test_serialize_basic(self): res = serialize.serialize('i', 'i', 1) self.assertEquals(res['name'], 'i') self.assertFalse(res['has_childs'])