def uncompyle(version, co, out=None, showasm=0, showast=0): ''' diassembles a given code block 'co' ''' assert type(co) == types.CodeType # store final output stream for case of error __real_out = out or sys.stdout if co.co_filename: print >> __real_out, '#Embedded file name: %s' % co.co_filename # diff scanner if version == 2.7: import scanner27 as scan scanner = scan.Scanner27() elif version == 2.6: import scanner26 as scan scanner = scan.Scanner26() elif version == 2.5: import scanner25 as scan scanner = scan.Scanner25() scanner.setShowAsm(showasm, out) tokens, customize = scanner.disassemble(co) #sys.exit(0) # Build AST from disassembly. walk = walker.Walker(out, scanner, showast=showast) try: ast = walk.build_ast(tokens, customize) except walker.ParserError, e: # parser failed, dump disassembly print >> __real_out, e raise
def queryDate(self, date, email, dog_id, cursor): sql_get_walkers = '''select dogWalker.w_email, dogWalker.w_telephone,dogWalker.w_name, week_day.price, week_day.day_name , breed.d_breed, week_day.maxDogs from dogWalker join week_day on dogWalker.w_email=week_day.w_email join breed on breed.w_email = dogWalker.w_email join dog on dog.dogID = %s where breed.d_breed = (select dog.d_breed from dog where dogID = %s) and week_day.day_name = dayname('%s') and dogWalker.w_email IN (select distinct week_day.w_email from week_day where day_name LIKE dayname('%s'));''' % (dog_id, dog_id, date, date) cursor.execute(sql_get_walkers) walker_records = cursor.fetchall() logging.error(date) date_list = self.w_RetrievedWalkers[date.strftime('%Y-%m-%d')] for walker_record in walker_records: current_walker = walker.Walker() logging.error(walker_record) current_walker.w_email = walker_record[0] current_walker.w_telephone = walker_record[1] current_walker.w_name = walker_record[2] current_walker.w_price = walker_record[3] current_trips = self.check_dog_capacity(date, current_walker.w_email, cursor) if current_trips ==-1 or current_trips < current_walker.w_price == walker_record[6]: date_list.append(current_walker) else: logging.error(current_walker.w_email) logging.error(walker_record[6]) return self.w_RetrievedWalkers
def __init__(self, graph, path_length, num_paths, dim, p=1.0, q=1.0, dw=False, **kwargs): kwargs["workers"] = kwargs.get("workers", 1) if dw: kwargs["hs"] = 1 p = 1.0 q = 1.0 self.graph = graph self.walker = walker.Walker(graph, p=p, q=q, workers=kwargs["workers"]) print "Preprocess transition probs..." self.walker.preprocess_transition_probs() sentences = self.walker.simulate_walks(num_walks=num_paths, walk_length=path_length) kwargs["sentences"] = sentences kwargs["min_count"] = kwargs.get("min_count", 0) kwargs["size"] = kwargs.get("size", dim) kwargs["sg"] = 1 self.size = kwargs["size"] print "Learning representation..." word2vec = Word2Vec(**kwargs) self.vectors = {} for word in graph.G.nodes(): self.vectors[word] = word2vec[word] del word2vec
def post(self): user = users.get_current_user() if self.request.get( 'telephone') == '': #check that telephone is not null parameters_for_template = { 'message': 'Seems like you didn\'t set a phone number. Please go back, and try again.' } template = jinja_environment.get_template('error_page.html') self.response.write(template.render(parameters_for_template)) return if user == None: #check that user is not null parameters_for_template = { 'message': 'Seems like your\'e logged out of a Google account. Please login, and try again.' } template = jinja_environment.get_template('error_page.html') self.response.write(template.render(parameters_for_template)) return if self.request.get('name') == None: #check that name is not null parameters_for_template = { 'message': 'Seems like you didn\'t enter your name. Please go back, and try again.' } template = jinja_environment.get_template('error_page.html') self.response.write(template.render(parameters_for_template)) return walker_data = walker.Walker() walker_data.w_email = str(user.email()) walker_data.w_name = str(self.request.get('name')) walker_data.w_city = str(self.request.get('city')) walker_data.w_telephone = str(self.request.get('telephone')) walker_data.w_breeds = self.get_breeds() week_days_result = self.get_week_days() if week_days_result: walker_data.w_days = week_days_result[0] walker_data.w_dog_num = week_days_result[1] walker_data.w_price = week_days_result[2] else: parameters_for_template = { 'message': 'Seems like you enter a wrong price or maximal dog number (they both have to be positive). Please go back, and try again.' } template = jinja_environment.get_template('error_page.html') self.response.write(template.render(parameters_for_template)) return walker_data.insertToDb() self.redirect('/walker-home')
def __init__(self): self.editor = editor.Editor() self.walker = walker.Walker(focus_attr='dropdown_walk') super(DropDown, self).__init__(header=urwid.AttrMap(self.editor, attr_map='dropdown_editor'), body=urwid.AttrMap(self.walker, attr_map='dropdown_plain'), focus_part='header') # The longest string in the options range. Updated in set_content() self.max_width = 1 self.selection = '' # The selected option returned to handling widget self._selectable = False
def read_file(self, file_name, file_num): ''' Inputs: file name of data to import, file number to act as data id Pulls data into nested listsself. Each file becomes a first-level item, each line in the file becomes a list of the items on that line. ''' fullFileName = self._directory + '\\' + file_name self._data.append([]) walker_data = walker.Walker() f = open(fullFileName) for line in f: data_line = line.split(',') walker_data.add_point(data_line) f.close() print("File ", file_name, " processed.") self._data[file_num] = walker_data
def __init__(self, graph, path_length, num_paths, dim, p=1.0, q=1.0, dw=False, **kwargs): kwargs["workers"] = kwargs.get("workers", 1) if dw: kwargs["hs"] = 1 p = 1.0 q = 1.0 self.graph = graph if dw: self.walker = walker.BasicWalker(graph, workers=kwargs["workers"]) else: self.walker = walker.Walker(graph, p=p, q=q, workers=kwargs["workers"]) # self.walker = walker.QuantumWalker(graph, p=p, q=q, workers=kwargs["workers"]) print("Preprocess transition probs...") self.walker.preprocess_transition_probs() sentences = self.walker.simulate_walks(num_walks=num_paths, walk_length=path_length) kwargs["sentences"] = sentences kwargs["min_count"] = kwargs.get("min_count", 0) kwargs["size"] = kwargs.get("size", dim) kwargs["sg"] = 1 self.size = kwargs["size"] print("Learning representation...") word2vec = Word2Vec(**kwargs) self.vectors = {} self.embeddings = np.zeros((graph.node_size, dim)) for word in graph.G.nodes(): self.vectors[word] = word2vec[word] self.embeddings[graph.look_up_dict[word]] = word2vec[word] del word2vec
def adiabaticWalk(total_walkers, total_vertices, time): timesteps = int(time / deltaT) # percentDone = 0.000 walkers = list() walkers = [ walker.Walker(random.randrange(2**total_vertices), total_vertices) for j in range(total_walkers) ] # randomize initial distribution s_old = 0.000 for t in range(timesteps): # random walk loop s = t / float(timesteps) # adiabatic scheduling parameter if (s - s_old > .001): print(s) output = [s] ll = histogram(walkers)[0].tolist() output.extend(ll) dist_writer.writerow(output) s_old += .001 walkers = diffuse(walkers, s) return walkers
def __init__(self, graph, path_length, num_paths, dim, p=1.0, q=1.0, dw=False, **kwargs): kwargs["workers"] = kwargs.get("workers", 5) if dw: kwargs["hs"] = 0 p = 1.0 q = 1.0 t1 = time.time() self.graph = graph if dw: self.walker = walker.BasicWalker(graph, workers=kwargs["workers"],walk_length=path_length) t2 = time.time() self.walker.preprocess_transition_probs() t3 = time.time() print("prob time: "+str(t3-t2)) sentences = self.walker.simulate_walks(num_walks=num_paths, walk_length=path_length) else: self.walker = walker.Walker( graph, p=p, q=q, workers=kwargs["workers"]) t2 = time.time() self.walker.preprocess_transition_probs() t3 = time.time() print("prob time: "+str(t3-t2)) sentences = self.walker.simulate_walks(num_walks=num_paths, walk_length=path_length) t2 = time.time() print("walking time: "+str(t2-t1)) kwargs["sentences"] = sentences kwargs["min_count"] = kwargs.get("min_count", 0) kwargs["size"] = kwargs.get("size", dim) kwargs["sg"] = 1 self.size = kwargs["size"] # print("Learning representation...") word2vec = Word2Vec(**kwargs) self.vectors = {} for word in graph.G.nodes(): self.vectors[word] = word2vec.wv[word] del word2vec
def __init__(self): super(Actor, self).__init__() self.l1 = nn.Linear(60, 256) self.l2 = nn.Linear(256, 256) self.l3 = nn.Linear(256, 4) def forward(self, state): a = F.relu(self.l1(state)) a = F.relu(self.l2(a)) return torch.tanh(self.l3(a)) def select_action(self, state): state = torch.FloatTensor(state.reshape(1, -1)).to(device) return self(state).cpu().data.numpy().flatten() env = walker.Walker() d = display.Display(60) actor = Actor() actor.load_state_dict(torch.load(f"./models/TD3_walk_targets_actor")) s, done, reward = env.reset(), False, 0 for _ in range(10000): act = np.random.random(4)*2 - 1 d.render(env) act = actor.select_action(s) s, r, done = env.step(act) reward += r if done: s, done, reward = env.reset(), False, 0
# create the maze: # ---------------- columns = 6 rows = 6 maze = maze.Maze(columns, rows) # size of maze (columns, rows) # Create the goal (you can move it around the maze, if you'd like): # ----------------------------------------------------------------- goal_column = randint(1, maze.get_columns()) goal_row = randint(1, maze.get_rows()) goal = goal.Goal(maze, goal_column, goal_row, "gold") # (maze, column, row, color) # Create a maze walker (you can assume that the walker starts at the top left corner (1, 1): # ------------------------------------------------------------------------------------------ walker = walker.Walker(maze, 1, 1, 0, "blue") # (maze, column, row, heading, color) # Placing blocking walls/tiles in the maze: # ----------------------------------------- # When putting walls and bridges in the maze, don't put them on the goal and the walker: excluded_blocks = [ [goal.get_column(), goal.get_row()], [walker.get_column(), walker.get_row()] ] # For testing/debugging purposes: # Block specific tiles in a 6-by-6 maze: ''' maze.block_square(1, 2, "wall") maze.block_square(1, 3, "wall") maze.block_square(2, 2, "wall") maze.block_square(2, 5, "wall") maze.block_square(3, 4, "wall")
#!/usr/bin/python3 import logging import walker logger = logging.getLogger("rainwalker") logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) logger.info("a") w1 = walker.Walker()
import pygame, draw, gameobject, scene, events, text, walker, platformer, snake, threading, space from pygame.locals import * pygame.init() pygame.display.set_caption('dbd') clock = pygame.time.Clock() bed = gameobject.GameObject('bed', 'assets/bed.png', 400, 200) sleepy = gameobject.GameObject('sleepy', 'assets/wakingup.png', 400, 200) textbox = gameobject.GameObject('textbox', 'assets/textbox.png', 64, 350, 128) walker = walker.Walker('walker', 'assets/walkingd.png', 570, 200) lunch = gameobject.GameObject('lunch', 'assets/lunchlady.png', 320, 200) essay = gameobject.GameObject('essay', 'assets/essay.png', 340, 100, 32, 32, 8) bedscene = scene.Scene() bedscene.add(bed) bedscene.add_actor(sleepy) lunchscene = scene.Scene() lunchscene.add_actor(walker) lunchscene.add(lunch) essayscene = scene.Scene() essayscene.add_actor(essay) scenes = [bedscene, lunchscene, essayscene] curscene = 0 gamevars = {'state': 1} def state(s=None): if s: gamevars['state'] = s return gamevars['state']
binList = list(range(n + 1)) def histogram(walkerList): histoList = list() for w in walkerList: histoList.append(w.hammingWeight()) return numpy.histogram(histoList, bins=binList, density=False) survivors = list() for j in range(initialwalkernum): # randomize initial distribution rando = random.randint(0, vertexnumber - 1) survivors.append(walker.Walker(rando, n)) #add a new walker percentDone = 0.000 for t in range(timesteps): # random walk loop s = t / float(timesteps) # adiabatic scheduling parameter writer.writerow((histogram(survivors)[0])) distfile.write(" %s \n" % (histogram(survivors)[0])) if s > percentDone: sys.stdout.write("\r %s %% Complete" % (percentDone * 100)) percentDone += 0.001 sys.stdout.flush() walkers = survivors survivors = list(
import math import argparse import shutil import sys import pack sys.setrecursionlimit(100) argparser = argparse.ArgumentParser() argparser.add_argument('-i', type=str) argparser.add_argument('-o', default=None, type=str) argsparsed = argparser.parse_args(sys.argv[1:]) state = tree.State() with open(argsparsed.i) as f: ast = state.parse(f.read()) conv = state.change(ast) conv.get() conv.captures() # conv.walk() walk = walker.Walker() walk.walk(conv) name, ext = argsparsed.o.split('.') if ext == 'txt': with open(argsparsed.o, 'w') as f: for pl, i in enumerate(walk.code): f.write(str(i) + '\n') elif ext == 'pack': with open(argsparsed.o, 'wb') as f: f.write(pack.packs(walk)) else: raise Exception('unknown extension ' + ext)