def split_call(toy, k): global COUNT, FCOUNT if not toy.params: # Case for no argument function calls if type(toy.fun) == str: return call(toy.fun, k) elif type(toy.fun) == func: return call(value(toy.fun), k) else: return call(split(toy.fun, k), k) else: # Normal case for any-argument calls received_expr = [] function_args = [] expressions = toy.params[::-1] + [toy.fun] for i in range(FCOUNT, len(expressions) + FCOUNT): function_args.append(new_var("f", i)) FCOUNT += len(expressions) last_expr = call(function_args[-1], [k] + function_args[0:-1][::-1]) for i in range(len(expressions)): received_expr.append(receive(expressions[i])) function_args.reverse() received_expr.reverse() for i in range(len(function_args)): last_expr = call(received_expr[i], func(function_args[i], last_expr)) return last_expr
def test_call(self): t_call = call(func([], 1), []) self.assertEqual(t_call.fun, func([], 1)) self.assertEqual(t_call.params, []) t_call = call(func(["x"], 1), [1]) self.assertEqual(t_call.fun, func(["x"], 1)) self.assertEqual(t_call.params, [1])
def projectinit(name,template,git=True): ''' Create a VT project directory by copying from a template resource tree. Args: name (str): Name of the new VT project directory. template (str): Template directory to copy from. git (bool): Whether to prepare the project directory for Git use. Yields: :func:`sys.exit` upon errors. Note: :func:`os.chdir`\ s into the new VT project directory! ''' try: shutil.copytree(template,name,symlinks=True) except OSError as exc: sys.exit('%s when initialising project directory from template'%exc) if git: try: os.chdir(name) call.call('git init',5) call.call('git add .',5) except call.callError as exc: sys.exit('Project directory created, but git initialization failed (%s)'%exc)
def call(self, uid, pwd, called, sign, pv, v, echo='1'): far_ip = cherrypy.request.remote.ip if 'User-Agent' in cherrypy.request.headers.keys(): ieinfo = cherrypy.request.headers['User-Agent'] if ieinfo.find('Mozilla') > -1: logger.info('受到恶意攻击!!!IP=%s, User-Agent=%s' % (far_ip, ieinfo)) return 'hehe' if (not uid) or (not called) or (not pwd) or (not sign) or (not pv) or (not v): logger.info('传入参数错误!') return '{"result":"-10"}' called = called.replace(' ', '') called = called.replace('-', '') if (called[0] == '+'): called = called[1:] if ((called.isdigit() == False) or (uid.isdigit() == False) or (echo != '0' and echo != '1')): logger.info('传入参数错误!') return '{"result":"-10"}' if sign != md5.new(uid + config.key).hexdigest(): return '{"result":"-6"}' try: ln = len(called) if ((ln >= 2) and (ln <= 4)): called = tool.get_called_by_cornet(uid, called) if called: result = call.call(uid, pwd, called, echo, far_ip) logger.info("pv=%s, v=%s, uid=%s, called=%s, echo=%s" % (pv, v, uid, called, echo)) return str(result) else: logger.info("%s呼叫%s,短号相应的号码获取失败" % (uid,called)) return '{"result":"-3"}' except: logger.info("call proc exception: %s " % traceback.format_exc()) return '{"result":"-11"}'
def check_for_objects(): while True: try: global last_epoch frame, found_obj = video_camera.get_object() if found_obj and (time.time() - last_epoch) > email_update_interval: last_epoch = time.time() call('+918465094927') sending(frame) print("all ok") now = datetime.now() current_time = now.strftime("%H:%M:%S") print(current_time) except: print("Error in sending email")
def free_call(self, caller, callee, pwd, agent_id, agent_name, sign): far_ip = cherrypy.request.remote.ip try: if (not caller) or (not callee) or (not pwd) or (not agent_id) or (not agent_name): logger.info('传入参数错误!') return '-1' if ((pwd.isalnum() == False) or (callee.isdigit() == False) or (caller.isdigit() == False)): logger.info('传入参数错误!') return '-1' if sign != md5.new(caller + config.key).hexdigest(): return '{"result":"-12"}' logger.info('free call: caller:%s,callee:%s,agent_id:%s,agent_name:%s' % (caller,callee,agent_id,agent_name.decode('gbk'))) passwd = tool.cryptData(pwd) result = reg.register(caller, passwd, agent_id, 1, far_ip) tmp = json.loads(result) res = tmp['result'] if callee == caller: return res else: if res != '0': return res result = call.call(str(tmp['uid']), passwd, callee, '1', far_ip) tmp = json.loads(result) return tmp['result'] except: logger.info("reg proc exception: %s " % traceback.format_exc()) return '-1'
def evaluate(points, *args): maxholder = args[0] value = call.call(points) if value > maxholder.get_x(): if acceptable.acceptable(points): maxholder.set_x(value) maxholder.set_points(points) return value
def sd(var, data, depth, index, context): if type(data) == str: if data == var: return [depth, index] else: return "_" elif type(data) == int: return data elif type(data) == func: rightness = 0 for arg in data.args: if arg != var: data.body = sd(var, data.body, depth + 1, index, context) data.body = sd(arg, data.body, 0, rightness, context + 1) else: data.body = sd(arg, data.body, depth, index, context + 1) rightness += 1 removed_s = [] for s in data.args: removed_s.append("_") data.args = removed_s return data elif type(data) == call: param_list = [] for param in data.params: param_list.append(sd(var, param, depth, index, context)) f = sd(var, data.fun, depth, index, context) return call(f, param_list) elif type(data) == cond: condition = sd(var, data.condition, depth, index, context) t = sd(var, data.true_expression, depth, index, context) f = sd(var, data.false_expression, depth, index, context) return cond(condition, t, f) elif type(data) == decl: if data.var != var: data.rhs = sd(var, data.rhs, depth, index, context) data.rhs = sd(data.var, data.rhs, 0, context, context) else: data.rhs = sd(data.var, data.rhs, 0, context, context) data.var = "_" return data elif type(data) == declSequence: seq = data.sequence seq.append(data.expr) new_sequence = sd(var, seq, depth, index, context) return declSequence(new_sequence) elif type(data) == list: if len(data) > 1: if type(data[0]) == decl: data[1:] = sd(data[0].var, data[1:], depth, context, context + 1) data[1:] = sd(var, data[1:], depth, index, context + 1) data[0] = sd(var, data[0], depth, index, context) else: if type(data[0]) == list: depth += 1 data[0] = sd(var, data[0], depth, index, context) return data
def test_parse_list(self): t_json = ["fun*", [], 1] self.assertEqual(parseList(t_json), func([], 1)) t_json = ["call", "+", 1, 2] self.assertEqual(parseList(t_json), call("+", [1, 2])) t_json = ["let", "x", "=", ["fun*", [], 1]] self.assertEqual(parseList(t_json), decl("x", func([], 1))) t_json = ["a", "b", "c"] self.assertEqual(parseList(t_json), ["a", "b", "c"])
def Ping(): call.call("logger ping.py started") output = call.call("ping -c4 www.google.com") print output f = open('log.txt', 'a') f.write(output) rate = output.find('received') if rate > 2: pack = rate - 2 p1 = output[pack] p = int(p1) else: p = 0 #print p if p < 3: restart = call.call("sudo service network-manager restart") time.sleep(30) call.call("logger network manager restarted by ping.py") print("network-manager restarted") f.close()
def reproject_to(ref_file, in_tag='orig', out_tag='repro', interpol_dict={'order': 3}, clobber=True): """Reproject cubes e.g. to match a HESS survey map. Can be computationally and memory intensive if the HESS map is large or you have many energy bands.""" logging.info('Reprojecting to {0}'.format(ref_file)) ref_image = FITSimage(ref_file) for ii in range(len(components)): in_file = filename(in_tag, ii) out_file = filename(out_tag, ii) logging.info('Reading {0}'.format(in_file)) in_image = FITSimage(in_file) logging.info('Reprojecting ...') out_image = in_image.reproject_to(ref_image.hdr, interpol_dict=interpol_dict) logging.info('Writing {0}'.format(out_file)) out_image.writetofits(out_file, clobber=clobber) logging.info('Copying energy extension') cmd = ['fappend', '{0}[ENERGIES]'.format(in_file), '{0}'.format(out_file)] call(cmd)
def parseList(jso): if len(jso) > 0: if jso[0] == "fun*": body = parse(jso[2]) return func(jso[1], body) if jso[0] == "call": params = [] for parameter in jso[2:]: params.append(parse(parameter)) c = call(parse(jso[1]), params) return c if jso[0] == "if-0": return cond(parse(jso[1]), parse(jso[2]), parse(jso[3])) if jso[0] == "let": return decl(jso[1], parse(jso[3])) # No need for infix operation checking in the list section, since it cannot happen if jso[0] == "seq*": args = [] for s in jso[1:-1]: p = parse(s) args.append(p) f = call(func(rand_stringer(len(args)), parse(jso[-1])), args[::-1]) return f if jso[0] == "grab": return grab(parse(jso[1]), parse(jso[2])) if jso[0] == "stop": return stop(parse(jso[1])) if type(jso) == list: return_array = [] for item in jso: return_array.append(parse(item)) if len(return_array) > 1 and type(return_array[0]) == decl: return declSequence(return_array) return return_array return jso
def split(toy, k): global COUNT if type(toy) == str: if toy in opList: return call(k, ops_mapping[toy]) return call(k, toy) if type(toy) == int: return call(k, toy) if type(toy) == func: return call(k, value(toy)) if type(toy) == call: return split_call(toy, k) if type(toy) == cond: conditional = cond("of-tst", split(toy.true_expression, k), split(toy.false_expression, k)) f = func(["of-tst"], conditional) return call(receive(toy.condition), f) if type(toy) == decl: toy.rhs = value(toy.rhs) return toy if type(toy) == declSequence: new_sequence = [] for declaration in toy.sequence: new_sequence.append(split(declaration, k)) toy.sequence = new_sequence toy.expr = split(toy.expr, k) return toy if type(toy) == grab: return declSequence( [decl(toy.var, func(["x", "f"], call(k, "f"))), split(toy.rhs, k)]) if type(toy) == list: if len(toy) < 1: return k # ? else: call_arg = func(["of-rst"], call(k, "of-rst")) f = func(["of-fst"], call(receive(toy[1:]), call_arg)) return call(receive(toy[0]), f) if type(toy) == stop: return stop(receive(toy.toy))
def handleList(toy, env, store): """ where handle list comes in: - single item lists - list of toy where the 2nd element will evaluate to a primop """ if len(toy) == 1: return interpret(toy[0], env, store) else: # plan: interpret each item in list R->L, check, then applyPrimop on [first, third->] prim, newStore = interpret(toy[1], env, store) if type(prim) == primop: args = toy[2:] args.insert(0, toy[0]) return primopApply(prim, args, env, newStore) elif type(prim) == funcVal: args = toy[2:] args.insert(0, toy[0]) return handleCall(call(toy[1], args), env, store) else: for i in toy[2:][::-1]: v, newStore = interpret(i, env, newStore) raise errors.ClosureOrPrimopExpected(newStore)
def test_cps(self): # Using the alpha_equals() for equality t_json = 1 parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k1"], call("k1", [1])) self.assertTrue(alpha_equal(cps, test)) t_json = "a" parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k2"], call("k2", ["a"])) self.assertTrue(alpha_equal(cps, test)) t_json = "+" parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k3"], call("k3", ops_mapping["+"])) self.assertTrue(alpha_equal(cps, test)) t_json = ["call", ["fun*", ["x", "y"], "y"], 1, 2] parsed_json = parse(t_json) cps = receive(parsed_json) test = func("k5", call(func("k6", call("k6", 2)), func("of-1", call(func("k7", call("k7", 1)), func("of-0", call(func(["k8"], call("k8", func(["k", "x", "y"], call("k", "y")))), func("of-f", call("of-f", ["k5", "of-0", "of-1"])))))))) self.assertTrue(alpha_equal(cps, test)) t_json = ["if-0", 0, 1, 2] parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k9"], call(func(["k10"], call("k10", [0])), func(["of-tst"], cond("of-tst", call("k9", [1]), call("k9", [2]))))) self.assertTrue(alpha_equal(cps, test)) t_json = [["let", "a", "=", 5], ["let", "b", "=", 6], "b"] parsed_json = parse(t_json) cps = receive(parsed_json) test = declSequence([decl("a", 5), decl("b", 6), func(["k11"], call("k11", ["b"]))]) self.assertTrue(alpha_equal(cps, test)) t_json = ["fun*", ["x"], "x"] parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k12"], call("k12", func(["k", "x"], call("k", ["x"])))) self.assertTrue(alpha_equal(cps, test)) # Unit tests against names we would generate t_json = ["fun*", ["kb"], "kb"] parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k12"], call("k12", func(["k", "kb"], call("k", ["kb"])))) self.assertTrue(alpha_equal(cps, test)) t_json = ["call", "+", 1, 2] parsed_json = parse(t_json) cps = receive(parsed_json) test = func("k13", call(func("k14", call("k14", 2)), func("of-1", call(func("k15", call("k15", 1)), func("of-0", call(func("k", call("k", ops_mapping["+"])), func("k", call("k", ["k13", "of-0", "of-1"])))))))) self.assertTrue(alpha_equal(cps, test)) t_json = ["grab", "x", ["call", "x", 10]] parsed_json = parse(t_json) cps = receive(parsed_json) test = func(["k"], declSequence([decl("x", func(["x", "f"], call("k", "f"))), call(func("kc", call("kc", 10)), func("fa", call(func("kd", call("kd", "x")), func("fb", call("fb", ["kb", "fa"])))))])) self.assertTrue(alpha_equal(cps, test)) t_json = ["stop", 10] parsed_json = parse(t_json) cps = receive(parsed_json) test = func("k", stop(func("kc", call("kc", 10)))) self.assertTrue(alpha_equal(cps, test)) t_json = ["call", "+", 1, ["stop", 10]] parsed_json = parse(t_json) cps = receive(parsed_json) test = func("k13", call(func("k", stop(func("kc", call("kc", 10)))), func("of-1", call(func("k15", call("k15", 1)), func("of-0", call(func("k", call("k", ops_mapping["+"])), func("k", call("k", ["k13", "of-0", "of-1"])))))))) self.assertTrue(alpha_equal(cps, test)) t_json = declSequence([decl("x", 15), "x"]) cps = receive(t_json) test = declSequence([decl("x", 15), func("ke", call("ke","x"))]) self.assertTrue(alpha_equal(cps, test))
def run(toy): app_form = func(["x"], stop("x")) cps_form = call(receive(toy), app_form) interp_ast(cps_form)
def test_seq(self): t_json_input = ["seq*", ["call", "+", ["call", "*", 5, 3], 1], -1] t_json_expected = call(func(["a"], -1), [call("+", [call("*", [5, 3]), 1])]) self.assertTrue(alpha_equal(parse(t_json_input), t_json_expected))
def call(params): callid = [params[1], params[2], params] callid = decode(callid) caller.call(callid)
import sys from call import call if __name__ == '__main__': if len(sys.argv) == 2: call(sys.argv[1]) else: print("Usage: python3 test.py YOURTEXTHERE")
def test_interpret(self): t_json = 1 parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 1) t_json = ["fun*", [], 1] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(str(result), "\"closure\"") t_json = "!" parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(str(result), "\"closure\"") t_json = ["call", "@", 1] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(str(result), "\"cell\"") t_json = "a" parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() self.assertRaises(errors.UndeclaredException, stop_catch_interpretter, call(toy, func(["x"], "x")), env, store_) t_json = ["call", "^", 1, -1] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() self.assertRaises(errors.exponentiationError, stop_catch_interpretter, call(toy, func(["x"], "x")), env, store_) t_json = ["call", "^", 1] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() self.assertRaises(errors.ArgumentParameterMismatch, stop_catch_interpretter, call(toy, func(["x"], "x")), env, store_) t_json = ["call", 1] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() self.assertRaises(errors.ClosureOrPrimopExpected, stop_catch_interpretter, call(toy, func(["x"], "x")), env, store_) t_json = ["grab", "c", ["call", ["fun*", ["v"], ["call", "v", 10]], "c"]] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 10) t_json = ["grab", "c", ["call", ["fun*", ["v"], ["call", "v", 10]], "c"]] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 10) t_json = ["call", "+", ["stop", [["let", "y", "=", 10], ["call", "^", 2, "y"]]], 10] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 1024) t_json = ["call", "*", ["call", ["fun*", [], 2]], 5] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 10) t_json = ["call", ["fun*", [], 1]] parsed_json = parse(t_json) toy = receive(parsed_json) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 1) toy = func("k13", call(func("k", stop(func("kc", call("kc", 10)))), func("of-1", call(func("k15", call("k15", 1)), func("of-0", call(func("k", call("k", ops_mapping["+"])), func("k", call("k", ["k13", "of-0", "of-1"])))))))) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 10) toy = func(["kb"], declSequence([decl("x", func(["x", "f"], call("kb", "f"))), call(func("kc", call("kc", 10)), func("fa", call(func("kd", call("kd", "x")), func("fb", call("fb", ["kb", "fa"])))))])) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 10) toy = func("k13", call(func("k14", call("k14", 2)), func("of-1", call(func("k15", call("k15", 1)), func("of-0", call(func("k", call("k", ops_mapping["+"])), func("k", call("k", ["k13", "of-0", "of-1"])))))))) env, store_ = interpret_init() result, new_store = stop_catch_interpretter(call(toy, func(["x"], "x")), env, store_) self.assertEqual(result, 3)
sex_list = ('F', 'M', 'FEMALE', 'MALE') for line in F1: sep = line.rstrip().split('\t') if sep[0] not in midpool: midpool[sep[0]] = [sep[3]] else: midpool[sep[0]].append(sep[3]) name_list.append(sep[2]) for batch in midpool.keys(): batch_out = os.path.join(options.outdir, batch) if os.system('mkdir -p ' + batch_out) != 0: raise Exception('Failed to create dir for %s: %s\n' % (batch, batch_out)) sys.stderr.write( 'Use samtools to get depth of each region for samples: %s\n' % ('\n'.join(midpool[batch]))) sample_depth = depth_combine(midpool[batch], options.bed, os.path.join(batch_out, batch + '.depth.txt'), name_list) sample_rpkm = rpkm(sample_depth, options.read_length, os.path.join(batch_out, batch + '.rpkm.txt')) sys.stderr.write( f'\nBegin to call CNV, threshold for deletion: {options.threshold_del}, duplication: {options.threshold_dup},sampleQC: {options.sampleQC}\n' ) call(sample_rpkm, options.threshold_del, options.threshold_dup, options.sampleQC, os.path.join(batch_out, batch + '.rpkm.txt')) sys.stderr.close()
def amp(self, res=75): return call.call(self.points, res)
def play(): cont = True while cont == True: win.fill(colour('black')) display.button(int(d_width * 5 / 6), int(0.8 * d_height), 120, 60, "d_red", "red", "quit") display.text_2_button(int(d_width * 5 / 6), int(0.8 * d_height), "QUIT", "calibri", "black", 35) cmd_attt = display.button1(0, 180, 140, parameter='attt') cmd_dab = display.button1(1, 400, 140, parameter='dab') cmd_pm = display.button1(2, 600, 140, parameter='pm') cmd_s = display.button1(3, 180, 300, parameter='s') cmd_sdk = display.button1(4, 400, 300, parameter='sdk') cmd_tt = display.button1(5, 600, 300, parameter='tt') cmd_t = display.button1(6, 300, 470, parameter='t') display.text_2_button(180, 212, "Angry TicTacToe", 'Candara', colour('cyan')) display.text_2_button(400, 210, "Dots and Boxes", 'CG Omega', colour('red'), b=1) display.text_2_button(600, 210, "Pac-Man", 'digifacewide', colour('d_yellow')) display.text_2_button(180, 372, 'Snakes', 'Consolas', colour('green')) display.text_2_button(400, 378, 'SuDoKu', 'Helvetica', colour('purple'), b=1) display.text_2_button(600, 372, 'Tank Maze', 'Monaco', colour('orange')) display.text_2_button(415, 470, 'Tanks', 'Eurostile', colour('d_grey'), size=30) #stripe motion effect global x global y win.blit(eff_blue_hr, (x - eff_red_hl.get_rect().width, 30)) win.blit(eff_red_hl, (d_width - x, 50)) win.blit(eff_green_hl, (d_width - x, d_height - 30)) win.blit(eff_lavender_hr, (x - eff_lavender_hr.get_rect().width, d_height - 50)) win.blit(eff_white_vu, (30, d_height - y)) win.blit(eff_cyan_vd, (50, y - eff_cyan_vd.get_rect().height)) win.blit(eff_yellow_vd, (d_width - 30, y - eff_yellow_vd.get_rect().height)) win.blit(eff_magenta_vu, (d_width - 50, d_height - y)) x += 2 y += 2 if x == d_width + eff_red_hl.get_rect().width: x = 0 if y == d_height + eff_white_vu.get_rect().height: y = 0 #icon buttons for event in pygame.event.get(): if event.type == pygame.QUIT: 1 / 0 else: pass clock.tick(200) pygame.display.update() ##launching game if cmd_attt != None: print('opening') call.call(cmd_attt) cmd_attt = None time.sleep(0.5) elif cmd_dab != None: call.call(cmd_dab) cmd_dab = None time.sleep(0.5) elif cmd_pm != None: call.call(cmd_pm) cmd_pm = None time.sleep(0.5) elif cmd_s != None: call.call(cmd_s) cmd_s = None time.sleep(0.5) elif cmd_sdk != None: call.call(cmd_sdk) cmd_sdk = None time.sleep(0.5) elif cmd_tt != None: call.call(cmd_tt) cmd_tt = None time.sleep(0.5) elif cmd_t != None: call.call(cmd_t) cmd_t = None time.sleep(0.5) else: pass
import operator from func import func from call import call from primop import primop from errors import exponentiationError opList = ["+", "*", "^", "@", "!", "="] ops_mapping = { "+": func(["k", "x", "y"], call("k", [call("+", ["x", "y"])])), "*": func(["k", "x", "y"], call("k", [call("*", ["x", "y"])])), "^": func(["k", "x", "y"], call("k", [call("^", ["x", "y"])])), "@": func(["k", "x"], call("k", [call("@", ["x"])])), "!": func(["k", "x"], call("k", [call("!", ["x"])])), "=": func(["k", "x", "y"], call("k", [call("=", ["x", "y"])])), } """ Below are the arithmetic/memory functions that evaluate prim-ops All of them take in an Array of arguments and return the operation applied to the arguments (The final argument is always a Store) """ def plus_op(a): return operator.add(*a[:2]), a[2] def mult_op(a): return operator.mul(*a[:2]), a[2]
"Name": [], "Action_rgb": [], "Romance_rgb": [], "Drama_rgb": [], "Horror_rgb": [], "Action": [], "Drama": [], "Horror": [], "Romance": [], "Action_audio": [], "Romance_audio": [], "Drama_audio": [], "Horror_audio": [] } path_dir = input("enter the path of the video folder\n") path = Path(path_dir) for video_path in os.listdir(path_dir): if video_path[0] != '.': new_path = os.path.join(path_dir, video_path) print(new_path) name = video_path.split(".")[0] result_dict = call.call(new_path) for key in final_dict.keys(): if (key == "Name"): final_dict[key].append(name) else: final_dict[key].append(result_dict[key][0]) df = pd.DataFrame(final_dict) df.to_csv(os.path.join(os.getcwd(), "final_results.csv"), index=False)
def add(self, new): self.calls.append(new) return self def remove(self): del self.calls[0] return self def info(self): for x in range(0, self.queue): print self.calls[x].name, self.calls[x].number return self # def removeuser(self,phonenumber): # for x in range(0,self.queue-1): # if self.calls[x].number == phonenumber: I'm going to come back to this assignment to achieve hacker eventually. # del self.calls[x] # return self call1 = call(1, "John", 123, "Need a car") call2 = call(2, "Mary", 456, "Have a car") call3 = call(3, "Does", 789, "Sold a car") calls = callcenter(call1, call2, call3) calls.info() # calls.removeuser(456) # calls.info()
def generate_icon(icon_in, icon_out, size): call('convert {} -resize {}x{} {}'.format(icon_in, size, size, icon_out))
status = match.text return status # Start in 2 hours #time.sleep(7200) url0 = 'https://www.bestbuy.com/site/nintendo-switch-32gb-console-neon-red-neon-blue-joy-con/6364255.p?skuId=6364255' # Red switch url1 = 'https://www.bestbuy.com/site/nintendo-switch-32gb-console-gray-joy-con/6364253.p?skuId=6364253' url2 = 'https://www.bestbuy.com/site/nintendo-switch-animal-crossing-new-horizons-edition-32gb-console-multi/6401728.p?skuId=6401728' headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.92 Safari/537.36'} counter = 0 status_list = [] # Red, Black, Green color of switch while True: counter += 1 status_list = [status(url0, headers), status(url1, headers), status(url2, headers)] #[Sold out, Sold out, Add to Cart] could be one of the examples time.sleep(1) print(datetime.now()) body = "Red is {0}, Black is {1}, Green is {2}".format(status_list[0], status_list[1], status_list[2]) # Sold Out, Add to Cart, Check Stores print(body) print('Number of visit: {0}\n'.format(counter)) if 'Add to Cart' in status_list: SendMail.sentmail() print("Calling you now....\n") call.call() time.sleep(13)
def handleStop(toy, env, store): if type(toy.toy) == str: raise errors.StopContinuation(toy.toy, env, store) raise errors.StopContinuation(call(toy.toy, func("asdasd", "asdasd")), env, store)
def dial(number=None): call.call(number) # Give a couple of seconds for the script to run # before respondng sleep(2) return "Calling %s " % (number)
def on_message(client, userdata, msg): print('Recieved message!') conn = psycopg2.connect(database="sensor_data2", user="******", password="******", host="127.0.0.1", port="5432") cur = conn.cursor() data=msg.payload.decode("utf-8") data=json.loads(data) print(data) today = date.today() d = today.strftime("%d/%m/%Y") print(type(d)) file1 = open("data.txt","r") user_id = file1.read() file1.close() cur.execute("INSERT INTO HEALTH_DATA2 (USER_ID,HR,BLOOD_OXYGEN_LEVEL,TEMPERATURE,BP_SYSTOLIC,BP_DIASTOLIC,DATE_TIME) \ VALUES ({},{},{},{},{},{},{})".format(user_id,data['hr'],data['blood_oxygen_level'],data['body_temperature'],data['blood_pressure_systolic'],data['blood_pressure_diastolic'],d)); condition = "" to_number = "+919057014880" #modify this to get nearest ambulance number conn2 = psycopg2.connect(database="User_Data2", user="******", password="******", host="127.0.0.1", port="5432") cur2 = conn.cursor() cur2.execute("SELECT * from User_Data2 where USER_ID={}".format(user_id)) rows = cur2.fetchall() user_age = rows[0]['AGE'] user_name = rows[0]['NAME'] call_needed = False if data['hr']>=(220-user_age): condition = "Tachycardia" call_needed = True elif data['hr']<40: condition = "Bradycardia" call_needed = True elif data['blood_oxygen_level']<0.6: condition = "Hypoxemia" call_needed = True elif data['body temperature']<35: condition = "Hypothermia" call_needed = True elif data['body temperature']>42: condition = "Hyperthermia" call_needed = True elif data['blood_pressure_systolic']<90 or data['blood_pressure_diastolic']<60: condition = "Hypotension" call_needed = True elif data['blood_pressure_systolic']>140 or data['blood_pressure_diastolic']<90: condition = "Hypertension" call_needed = True if call_needed: location = "" #find location message = "Alert! User {} is suffering from {} at location {}".format(user_name,condition,location) call(to_number,message) conn.commit() conn.close() print('Insertion Complete!') file1 = open("data.txt","w") file1.write(str(int(user_id)+1)) file1.close()