def main():
log("Starting Pyrox...")
init_gl()
director.init(resizable=True, caption=GAME_NAME, width=WINDOW_WIDTH, height=WINDOW_HEIGHT)
director.window.set_icon(window_icon)
game_scene = Game()
director.run(game_scene)
def search_series_urls_by_name(name):
log('searching "{}"'.format(name))
page = fetch_url(base_url + "/search?keyword=" + name.replace(' ', '+'))
soup = BeautifulSoup(page, SOUP_PARSER_HTML)
posters = soup.find_all('a', {'class': 'poster'})
names = [poster.find('img')['alt'] for poster in posters]
urls = [poster['href'] for poster in posters]
return names, urls
def __init__(self, position, obj=None):
super(Camera, self).__init__()
log("Initialize Camera object")
self.position = position
self.width = WINDOW_WIDTH
self.height = WINDOW_HEIGHT
self.follow_obj = obj
self.schedule(self.update)
def _find_episode_watch_links(self, series_page_html):
hosts = _find_all_servers_and_eps(series_page_html)
bold('Found {} Servers:'.format(len(hosts.keys())))
log('\n'.join([
'{}:\t{}'.format(server_name,
[ep.ep_number for ep in hosts[server_name]])
for server_name in hosts
]))
return hosts[self.get_server_name()]
def __init__(self, position):
super(Player, self).__init__(position, player_stay)
log("Initialize Player object. Position: %i:%i" % position)
self.speed = TILE_SIZE
self.sight_radius = 6
self.buttons = set()
self.minimap_color = (0, 250, 0)
def _add_counterexample_with(self, fml, c0_exists, exp=None):
res, c1 = self._prove(fml=fml, exp=exp)
if res == sat:
self._add_counterexample(c1)
elif res == unsat and c0_exists:
# couldn't get a counterexample with sum(x^exp == 1), but got a counterexample to the first formula
log("res == unsat, ex is not None. Exponents: %s" %
str(self._synth_counterexamples_exp))
self._error = True
return res
def on_transform_completed(self, result: TransformResult):
log(result)
if result is None:
return
try:
result.apply(self.df, self.vp)
except ValueError as e:
print('transform error:', e)
self._refresh()
def _solve(self, min_sum=None, max_sum=None):
res = None
self._solver.push()
if min_sum is not None:
sum_vars = reduce(lambda rem, item: item + rem, self.P_z3, 0)
self._solver.add(sum_vars >= min_sum)
if max_sum is not None:
if min_sum is None:
sum_vars = reduce(lambda rem, item: item + rem, self.P_z3, 0)
self._solver.add(sum_vars <= max_sum)
self._set_timeout()
r, self._has_timedout = check_with_timeout(self._solver, self._timeout)
if r == sat:
m = self._solver.model()
log("Learner's s: %s" % self._solver)
log("Model %s" % m)
res = Model2Matrix(m, self.P_sym, symmetric=True, target='z3')
self._error = self._has_timedout
elif r == unsat:
log("unsat")
self._error = True
elif r == unknown and not self._has_timedout:
log("unknown")
self._error = True
self._solver.pop()
if self._error or self._has_timedout or res is None:
log("Could not solve the system with min/max_sum %s %s" % (min_sum, max_sum))
if max_sum is not None and min_sum is not None:
return self._solve(min_sum=None, max_sum=None)
self._error = True
return unsat
# try:
# min_val = min(*(_x for _x in res if _x > 0))
# except:
# min_val = 1
#
# inv_min = 1 / min_val
# if self._multiply_by_inv_min:
# res = res.applyfunc(lambda x: x * inv_min)
res_matrices = res
# for P in self.P_sym:
# res_matrices.append(
# P.subs({self.P_sym[p]: res[p] for p in res})
# )
return res_matrices
def __init__(self):
super(Game, self).__init__()
log("Starting Game_Scene...")
self.input = Input()
self.add(self.input, z=0, name='input')
self.game_layer = self.get_game_layer()
self.add(self.game_layer, z=1, name='game_layer')
self.hud_layer = self.get_hud_layer()
self.add(self.hud_layer, z=3, name='hud_layer')
def __init__(self):
super(GameLayer, self).__init__()
log("Initialize Game_Layer")
self.level = level_manager.generate_level(5)
self.add(self.level)
self.cam = Camera(self.level.player.position, self.level.player)
self.add(self.cam)
self.schedule(self.update)
self.schedule_interval(self.update_second, 1)
def learn(self):
"""
:return: True iff a solution has been computed. Use get_solution() to retrieve it
"""
if self.iter > -1:
self.solution = self._solve(min_sum=self._min_sum, max_sum=self._max_sum)
log("learner %s" % self.solution)
else:
# correct solution of 6-dim [sp.diag(1, 0, 3, 3, 0, 2), sp.diag(0, 2, 0, 0, 1, 0)]
self.solution = [ -sp.Identity(self.n), sp.zeros(self.n, self.n) ]#[+sp.Identity(self.n) for _ in range(len(self.P_sym))]
res = self._valid_sol(self.solution)
self.iter += 1
return res
def download_file_from_multiple_sources(urls, path, headers=None):
log('downloading {} from multiple urls'.format(path))
# if not os.path.exists(path):
# os.makedirs(path)
headers = make_headers_with_user_agent(headers)
with open(path, 'wb') as f:
for i, url in enumerate(urls):
# file_name = url[url.rfind('/') + 1:]
# file_path = os.path.join(path, file_name)
f.write(fetch_url(url, headers=headers, return_bytes=True))
print('\r{}/{}...'.format(i, len(urls)), end='')
print()
log('finished downloading {}'.format(path))
return
def learn(self):
"""
:return: True iff a solution has been computed. Use get_solution() to retrieve it
"""
if self.iter > -1:
self.solution, self._has_timedout = self._solve(
min_sum=self._min_sum, max_sum=self._max_sum)
log("learner %s" % self.solution)
else:
self.solution = [
-sp.Identity(self.n) for _ in range(len(self.P_sym))
]
res = self._valid_sol(self.solution)
self.iter += 1
return res
def on_configure_drawing_area(self, drawing_area, event):
log(event)
window = drawing_area.get_window()
width = drawing_area.get_allocated_width()
height = drawing_area.get_allocated_height()
self.vp = Viewport(size=Size(width, height), on_changed=self._refresh)
self.surface = window.create_similar_surface(
cairo.CONTENT_COLOR,
width,
height,
)
self._refresh()
return True
def set_exponents_counterexample(self, es):
"""
Counterexamples x=(x0, x1, ..) will be generated such that their sum x0^i + x1^i + .. = 1 for i in es
:param es: list of exponents
:return: self
"""
if isinstance(es, list):
self._synth_counterexamples_exp = set(es)
elif isinstance(es, (int, long, float)):
self._synth_counterexamples_exp = {i for i in range(es)}
else:
log("Cannot accept exponents: %s" % str(es))
self._error = True
assert all(i >= 0 for i in self._synth_counterexamples_exp)
self._max_counterexamples = len(self._synth_counterexamples_exp) + 1
return self
def set_quality(self, requested_quality):
requested_quality = G3F4AndWhatever.QUALITIES[requested_quality]
self._navigate('https://9anime.to/')
current_quality = self.driver.execute(
Command.GET_LOCAL_STORAGE_ITEM, {'key': 'player_quality'})['value']
if current_quality is not None:
current_quality = current_quality.lower()
if current_quality != requested_quality.lower():
log('current quality: {}; changing to {}...'.format(
current_quality, requested_quality))
self.driver.execute(Command.SET_LOCAL_STORAGE_ITEM, {
'key': 'player_quality',
'value': requested_quality
})
return
def is_valid_matrix_A(A):
"""
:param A: matrix
:return: True iff the parameter is a valid (system) A matrix
"""
A = sp.Matrix(A)
is_squared = A.shape[0] == A.shape[1]
is_real_and_neg = all(sp.re(sp.simplify(sp.re(l))) <= 0 for l in A.eigenvals().keys())
valid = A is not None and \
hasattr(A, "shape") and hasattr(A.shape, "__len__") and \
len(A.shape) == 2 and \
is_squared and \
is_real_and_neg
if not valid:
log("Invalid A: (squared, %s), (real and negative eig, %s)" % (is_squared, is_real_and_neg))
print('A eigenvalues are: {}'.format(A.eigenvals().keys()))
return valid
def _find_download_url(self, ep_page_html):
soup = BeautifulSoup(ep_page_html, SOUP_PARSER_HTML)
link = soup.find(attrs={'id': 'player'}).find('iframe')['src']
# link = link[:link.index('?')] # no 'autostart=True' parameter
self._navigate(link)
sleep(3)
actual_page = self.driver.page_source
soup = BeautifulSoup(actual_page, SOUP_PARSER_HTML)
home_video_div = soup.find('div', id='home_video')
links = [a['href'] for a in home_video_div.find_all('a')]
log('links found in RapidVideo: {}'.format(links))
for q in RapidVideo.QUALITY_ORDER:
for link in links:
if '&q={}p'.format(q) in link:
log('highest resolution found: {}p'.format(q))
soup = BeautifulSoup(fetch_url(link), SOUP_PARSER_HTML)
return soup.find('source')['src']
raise RuntimeError('can\'t find download link')
def diagonalize(M, real=True):
"""
M = U D U^T
:param M: a matrix-like object (list, NumPy/SymPy matrix)
:param real: True iff D, U need to have only real elements
:return: None iff M is not diagonalizable; (D, U) otherwise
"""
M = sp.Matrix(M)
if is_diagonal(M):
return M, sp.eye(M.shape[0])
try:
# O = U * D * U.T
D, U = M.diagonalize()[::-1] # D, U
if real and (len(D.atoms(sp.I)) > 0 or len(U.atoms(sp.I)) > 0): # imaginary unit
log("Could not diagonalize: %s. M: %s" % ("D, U have complex numbers", M))
return None
return D, U
except Exception as e:
log("Could not diagonalize: %s. M: %s" % (e, M))
return None
def download_episodes(self, series_page_url, requested_episodes, quality,
download_path):
series_page_html = fetch_url(series_page_url)
available_episodes = self._find_episode_watch_links(series_page_html)
# region quality
if quality is None:
quality = self.highest_quality()
warning('no specific quality was requested; '
'using highest quality ({}) available in this server ({})'.
format(quality, self.get_server_name()))
self.set_quality(quality)
# endregion
episodes_to_download = self.intersect_availible_and_requested_episodes(
available_episodes, requested_episodes)
ep_fmt = 'ep{ep:03d}.{extension}'
for download_url, ep in zip(
self._travel_episodes(series_page_url, episodes_to_download),
episodes_to_download):
log('found download url for episode {}!'.format(ep.ep_number))
if not os.path.exists(download_path):
os.makedirs(download_path)
if type(download_url) is str:
download_file(
download_url,
os.path.join(
download_path,
ep_fmt.format(ep=ep.ep_number, extension='mp4')),
self.get_headers())
else:
download_file_from_multiple_sources(
download_url,
os.path.join(
download_path,
ep_fmt.format(ep=ep.ep_number, extension='ts')),
self.get_headers())
return
def check(self, P):
"""
:param P: matrix
:return: unsat if there have been found no counterexamples, sat if there have been found and unknown otherwise
"""
self._solver = Solver()
self._set_timeout()
log("Verifier got P %s" % P)
V, Vd = self._V, self._Vd
for i in range(len(self._P_sym)):
V = V.subs({
self._P_sym[i][r, c]: P[i][r, c]
for r in range(self.n) for c in range(self.n)
})
Vd = Vd.subs({
self._P_sym[i][r, c]: P[i][r, c]
for r in range(self.n) for c in range(self.n)
})
_, _, V = sympy_converter(V.doit()[0])
_, _, Vd = sympy_converter(Vd.doit()[0])
if V == 0 or Vd == 0:
log("error: P=0")
return sat
fml = Implies(OrNotZero(self._xs_z3), And(V >= 0, Vd <= 0))
res, c0 = self._prove(fml, exp=0)
if res == sat:
self._add_counterexample(c0)
self._solver.push() # keep fml
self._generate_counterexamples(c0 is not None)
self._solver.pop()
return res
def download_file(url, file_path, headers=None):
log('downloading: {} -> {}'.format(url, file_path))
url = make_safe_url(url)
headers = make_headers_with_user_agent(headers)
download_statistics = DownloadStatistics()
response = requests.get(url, stream=True, headers=headers)
chunk_size = 4096
if CONTENT_LENGTH in response.headers.keys():
total_size = int(response.headers[CONTENT_LENGTH])
else:
total_size = None
with open(file_path, 'wb') as outfile:
for i, data in enumerate(response.iter_content(chunk_size=chunk_size)):
outfile.write(data)
my_reporthook(i, chunk_size, total_size, download_statistics)
# urlretrieve(url=url, filename=file_path, reporthook=my_reporthook, data=headers)
print()
log('finished downloading {}'.format(file_path))
return
def _prove(self, fml=None, exp=0, orth=False):
if fml is not None:
self._solver.add(Not(fml))
self._solver.add(self._x_precision)
if orth:
self._solver.add(self._orthogonal_counterexamples(self._xs_z3))
if exp > 0:
self._solver.add(self._sum_powers(self._xs_z3, exp) == 1)
log("s %s" % self._solver)
res, self._has_timedout = check_with_timeout(self._solver,
self._timeout)
counterexample = None
if res == unknown and not self._has_timedout:
self._error = True
elif res == sat:
model = self._solver.model()
counterexample = model_to_vector(model,
self._xs_z3,
N=self.n,
target_z3=self._z3_learner)
log("counterexample found #%s %s" % (str(self._iter + 1), model))
else:
log("proved")
return res, counterexample
def _add_constraint(self, counterexample):
for V_sym, Vd_sym in izip(self.V_list_sym, self.Vd_list_sym):
V = V_sym.subs(
{x: c
for x, c in izip(self._xs_sym, counterexample)})
Vd = Vd_sym.subs(
{x: c
for x, c in izip(self._xs_sym, counterexample)})
_, __, V = convert.sympy_converter(V,
var_map=self.P_map,
target=convert.TARGET_SOLVER)
_, __, Vd = convert.sympy_converter(Vd,
var_map=self.P_map,
target=convert.TARGET_SOLVER)
try:
self.model.addConstr(V >= consts.ZERO)
self.model.addConstr(Vd <= -consts.ZERO)
self.model.update()
except Exception as e:
log('Could not add counterexample: %s. (V:%s, Vd:%s). Exception: %s'
% (counterexample, V, Vd, e))
def find_series_url_by_name(name):
results = [
url for _name, url in zip(*search_series_urls_by_name(name))
if name == sanitize_name(_name)
]
if len(results) == 0:
log("watching page of {} couldn't be found. please check for typos or switch to names in opposite language (english/japanese)"
.format(name))
raise Exception()
elif len(results) > 1:
log("more than 1 result were found for {}, choosing the first one;".
format(name))
result = results[0]
log('found watching page of {}: {}'.format(name, result))
return result
def __init__(self, dungeon, start_tile, creatures, objects):
print creatures
super(Level, self).__init__()
self.objects = objects
self.creatures = creatures
self.dungeon = dungeon
self.width = len(dungeon[0])
self.height = len(dungeon)
for y in range(self.height):
for x in range(self.width):
if self.dungeon[y][x]:
self.add(self.dungeon[y][x])
for obj in self.objects:
self.add(obj)
tile = self.get(obj.x, obj.y)
if not tile.object_on:
tile.object_on = obj
for creature in self.creatures:
self.add(creature)
tile = self.get(creature.x, creature.y)
if not tile.creature_on:
tile.creature_on = creature
# Player here
self.start_pos = dungeon[start_tile[1]][start_tile[0]].center
self.player = Player(self.start_pos)
self.add(self.player)
self.creatures.append(self.player)
self.collman = cm.CollisionManagerGrid(0, WINDOW_WIDTH, 0, WINDOW_HEIGHT, TILE_SIZE, TILE_SIZE)
self.schedule(self.update)
log("Loading Level object, map sise: %i:%i" % (self.width, self.height))
log("Count of creatures: %i. Count of Objects: %i" % (len(self.creatures), len(self.objects)) )
for x in self.get_children():
if x.type != OBJECT_TILE:
log(str(x))
def __init__(self, position, img):
super(Enemy, self).__init__(position, img)
log("Initialize Enemy object. Position: %i:%i" % position)
self.speed = TILE_SIZE
self.minimap_color = (250, 0, 0)
def post_tweet(self, text: str) -> Status:
log(f"Fake Tweet Sent: \"{text}\"")
status = Status()
status._json = {"text": f"{text}"}
return status
from src.cegis import Cegis
from src.common import createPoly, createFX
from src.linearize import linearize
from src.log import log
from src.z3_learner import IterativeZ3Learner
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="Synthesize Lyapunov functions")
parser.add_argument('-e', '--exponent')
parser.add_argument('-n', '--dimension')
args = parser.parse_args(sys.argv[1:])
e = args.exponent
n = args.dimension
log("Running with e=%s n=%s" % (e, n))
if e is None or n is None:
log("e and n must be set")
sys.exit(1)
e = int(e)
n = int(n)
roots = [- randint(0, 9) for _ in range(n)]
p = sp.Poly(createPoly(roots))
fx = createFX(p)
A = linearize(fx)
c = Cegis(A)
c.set_learners([IterativeZ3Learner])
assert c.solve(exponent=e)
P = c.get_P()
def on_exit(self):
super(GameLayer, self).on_exit()
log("On exit call from game_layer")
def on_zoom_in_pressed(self, *args):
self.vp.zoom_in()
log(self.vp)
def _solve(self, min_sum=None, max_sum=None):
m0 = self.model.copy()
res = {}
try:
# if min_sum is not None:
# sum_vars = reduce(lambda rem, item: m0.getVarByName(str(item)) + rem, self.P_vars, 0)
# m0.addConstr(sum_vars >= min_sum)
#
# if max_sum is not None:
# if min_sum is None: # sum_vars already computed
# sum_vars = reduce(lambda rem, item: m0.getVarByName(str(item)) + rem, self.P_vars, 0)
# m0.addConstr(sum_vars <= max_sum)
#
# if self._close_diagonal_by > 0:
# diag = diagonal_names(self.n, prefix='P')
# for p in diag:
# for q in diag:
# if p != q:
# vp = m0.getVarByName(p)
# vq = m0.getVarByName(q)
# m0.addConstr(vp - vq <= self._close_diagonal_by)
# m0.addConstr(vq - vp <= self._close_diagonal_by)
# objective = reduce(lambda rem, item: m0.getVarByName(str(item)) + rem, self.P_sym, 0)
# m0.setObjective(objective, gp.GRB.MINIMIZE) # optional
self._set_timeout(m0)
m0.update()
self._debug_model(m0)
m0.optimize()
if m0.status == gp.GRB.Status.TIME_LIMIT:
log("timed out")
self._has_timedout = True
else:
# min_val = float('inf')
for v in m0.getVars():
log("%s %g" % (v.varName, v.x))
res[v.varName] = v.x
# if v.x > 0:
# min_val = min(min_val, v.x)
# if self._multiply_by_inv_min:
# inv_min = 1 / min_val
# res = {k: v * inv_min for k, v in res.items()}
log('Obj: %g' % m0.objVal)
self._error = False
except gp.GurobiError as e:
log("Error code %d : %s" % (e.errno, e))
self._error = True
except AttributeError as e:
log("Attribute error: %s" % e)
self._error = True
if self._error:
log("Could not solve the system with min/max_sum %s %s" %
(min_sum, max_sum))
# if max_sum is not None and min_sum is not None:
# return self._solve(min_sum=None, max_sum=None)
self._error = True
return unsat, self._has_timedout
res_matrices = []
for P in self.P_sym:
res_matrices.append(
P.subs({self.P_sym_map[p]: res[p]
for p in res}))
return res_matrices, self._has_timedout
def make_random_room(self):
assert len(self.rooms) > 0, "A main room must me created"
prefer_direction = set()
if (self.width > self.height):
prefer_direction.add(UP)
prefer_direction.add(DOWN)
else:
prefer_direction.add(RIGHT)
prefer_direction.add(LEFT)
rooms = filter(lambda x: len(x.free_direction) > 0 and len(set(x.free_direction) & prefer_direction) > 0,
self.rooms)
# TODO: ставить комнату в непредпочтитетльную сторону при остутствии предпочтительных?
room_from = choice(rooms)
dirs = set(room_from.free_direction) & prefer_direction
direction = choice(list(dirs))
door_from = room_from.get_random_wall_pos(direction)
room_new = None
for i in range(GEN_MAX_TRY_PLACE_ROOM):
hall_len = randint(HALL_MIN_LENGTH, HALL_MAX_LENGTH)
door_new = get_new_pos_by_direction(door_from[0], door_from[1], hall_len, direction)
room_width = randint(ROOM_MIN_WIDTH, ROOM_MAX_WIDTH)
# if (room_width == 3):
# room_height = 3
# else:
room_height = randint(ROOM_MIN_HEIGHT, ROOM_MAX_HEIGHT)
room_x = door_new[0]
room_y = door_new[1]
if (direction == UP):
room_x -= room_width // 2
room_y -= room_height - 1
elif (direction == RIGHT):
room_y -= room_height // 2
elif (direction == DOWN):
room_x -= room_width // 2
elif (direction == LEFT):
room_y -= room_height // 2
room_x -= room_width - 1
room_new = Room(room_x, room_y, room_width, room_height)
hall_new = Hall(door_from, door_new)
for room in self.rooms:
if room_new.overlaps(room):
room_new = None
break
# If new room was not created
if (room_new == None):
log("Cannot create new room, remove aviable direction")
room_from.free_direction.remove(direction)
return
room_from.free_direction.remove(direction)
room_new.free_direction.remove((direction + 2) % 4)
self.halls.append(hall_new)
self.rooms.append(room_new)
self.compile()
def on_left_pressed(self, *args):
self.vp.move(Direction.LEFT)
log(self.vp)
def on_rotate_counterclockwise_pressed(self, *args):
self.vp.rotate_counterclockwise()
log(self.vp)
def on_zoom_out_pressed(self, *args):
self.vp.zoom_out()
log(self.vp)
def _debug_model(self, m0, filename="/tmp/gurobi.lp"):
if self.debug_model:
m0.write(filename)
with open(filename) as content:
log(content.read())
def on_down_pressed(self, *args):
self.vp.move(Direction.DOWN)
log(self.vp)
def on_right_pressed(self, *args):
self.vp.move(Direction.RIGHT)
log(self.vp)
