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)
