def post(self, category=None):
"""Feedback form post"""
user = users.get_current_user()
prefs = InternalUser.from_user(user)
values = {'prefs': prefs}
msg = decode(self.request.get('msg'))
#logging.info("msg: %s" % msg)
if msg:
if prefs:
sender = "%s (%s)" % (prefs.nickname, prefs.email)
else:
sender = decode(self.request.get('email'))
logging.info("feedback '%s' from %s" % (msg, sender))
message = mail.EmailMessage()
message.sender = "Android Snippets <*****@*****.**>"
message.to = "*****@*****.**"
message.subject = "Android snippets feedback"
message.body = "Feedback from: %s:\n\n%s" % (sender, msg)
message.send()
values["info"] = "Thank you, we have received your feedback."
self.response.out.write( \
template.render(tdir + "about.html", values))
def action(self):
t = self.file.readline()
if t == '':
time.sleep(1)
elif t[:5] == "From:":
self.mfrom = decode(t[5:].strip())
elif t[:8] == "Subject:":
self.msubject = decode(t[8:].strip())
elif t[:13] == "X-Spam-Score:":
try:
self.spam = float(t[14:].strip())
except:
self.spam = -2
elif t[:14] == "X-Spam-Status:":
try:
self.spam = float(t[14:].split("=")[1].split()[0].strip())
except:
self.spam = -2
if self.mfrom != "" and self.msubject != "":
if self.spam < 0:
try:
self.bot.say(">> Mail de %s : %s (Spam Score : %f)" %
(self.mfrom, self.msubject, self.spam))
except:
self.bot.say(">> Mail de %s : <encodage foireux> (Spam Score : %f)" %
(self.mfrom, self.spam))
self.mfrom = ""
self.msubject = ""
self.spam = -1
def get(self, category=None):
user = users.get_current_user()
prefs = InternalUser.from_user(user)
values = {'prefs': prefs, "stats": []}
mc_items = ["pv_login", "pv_main", "pv_profile", "pv_snippet", \
"pv_snippet_legacy", "ua_vote_snippet", "ua_edit_snippet", \
"pv_snippet_edit", "pv_tag", "ua_comment", "ua_comment_spam", \
"ua_comment_ham", "pv_otherprofile", "pv_search", "pv_userlist", \
"pv_snippet_404", "_last_reset"]
mc_items.sort()
if not category:
self.response.out.write( \
template.render(tdir + "admin.html", values))
if category == "/stats":
for item in mc_items:
values["stats"].append((item, memcache.get(item)))
self.response.out.write( \
template.render(tdir + "admin_stats.html", values))
if category == "/stats/reset":
for item in mc_items:
memcache.set(item, 0)
memcache.set("_last_reset", datetime.datetime.now())
self.redirect("/admin/stats")
if category == "/revision":
key = decode(self.request.get('k'))
action = decode(self.request.get('a'))
if key:
rev = SnippetRevision.get(db.Key(key))
if rev:
if action == "1":
# use as default
rev.merge(prefs)
elif action == "2":
# delete revision
for v in rev.snippetrevisionupvote_set:
v.delete()
for v in rev.snippetrevisiondownvote_set:
v.delete()
rev.snippet.proposal_count -= 1
rev.snippet.put()
rev.delete()
self.redirect("/admin/revision")
return
values["rev"] = rev
self.response.out.write( \
template.render(tdir + "admin_rev.html", values))
else:
revs = SnippetRevision.all()
revs.filter("merged =", False)
revs.order("-date_submitted")
values["revs"] = revs.fetch(40)
self.response.out.write( \
template.render(tdir + "admin_revlist.html", values))
def get(self):
memcache.incr("pv_userlist", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
q = decode(self.request.get('q'))
p = decode(self.request.get('p'))
_users = InternalUser.all()
if q == "1" or not q:
_users.order("-points")
else:
#_users.filter("date_lastactivity !=", None)
_users.order("-date_lastactivity")
page = int(p) if p else 1
items_per_page = 40
n = items_per_page / 2
offset = (page - 1) * items_per_page
_users1 = _users.fetch(n, offset)
_users2 = _users.fetch(n, (offset + (items_per_page / 2)))
values = {'prefs': prefs, 'users1': _users1, 'users2': _users2,
'page': page, 'pages': range(1, page), 'prefix': q}
self.response.out.write( \
template.render(tdir + "users.html", values))
def action(self):
t = self.file.readline()
if t == '':
time.sleep(1)
elif t[:5] == "From:":
self.mfrom = decode(t[5:].strip())
elif t[:8] == "Subject:":
self.msubject = decode(t[8:].strip())
elif t[:13] == "X-Spam-Score:":
try:
self.spam = float(t[14:].strip())
except:
self.spam = -2
elif t[:14] == "X-Spam-Status:":
try:
self.spam = float(t[14:].split("=")[1].split()[0].strip())
except:
self.spam = -2
if self.mfrom != "" and self.msubject != "":
if self.spam < 0:
try:
self.bot.say(">> Mail de %s : %s (Spam Score : %f)" %
(self.mfrom, self.msubject, self.spam))
except:
self.bot.say(
">> Mail de %s : <encodage foireux> (Spam Score : %f)"
% (self.mfrom, self.spam))
self.mfrom = ""
self.msubject = ""
self.spam = -1
def create_files(src, inputfile, algorithm, language):
# creating input file with right extension
with open("in.{}".format(src), "w+") as data_to_parse:
data_to_parse.write(decode(inputfile).decode('utf-8'))
# creating code files
if language == "python":
with open("code.py", "w+") as code_to_run:
code_to_run.write(decode(algorithm).decode('utf-8'))
def post(self):
n1 = decode(self.request.get('n1'))
n2 = decode(self.request.get('n2'))
if not n1 or not n2:
self.response.out.write("""username not found""")
return
u1 = InternalUser.all().filter("nickname =", n1).get()
u2 = InternalUser.all().filter("nickname =", n2).get()
action = decode(self.request.get('action'))
if action == "do":
# move snippets
cnt1 = 0
for snippet in u1.snippet_set:
snippet.userprefs = u2
snippet.put()
cnt1 += 1
cnt1_2 = 0
for rev in u1.snippetrevision_set:
rev.userprefs = u2
rev.put()
cnt1_2 += 1
# move comments
cnt2 = 0
for comment in u1.snippetcomment_set:
comment.userprefs = u2
comment.put()
cnt2 += 1
if u1.points:
u2.points += u1.points
u2.put()
self.response.out.write("""Moved %s snippets, %s revisions, %s
comments and %s points from '%s' to '%s'""" % (cnt1, \
cnt1_2, cnt2, u1.points, u1.nickname, u2.nickname))
return
self.response.out.write("""<form action="/admin/mapsnippets_post" method="post">
<input type="hidden" name="n1" value="%s" />
<input type="hidden" name="n2" value="%s" />
<input type="hidden" name="action" value="do" />
<table border="0"><tr><td>From User:</td><td>%s</td></tr>
<tr><td>To User:</td><td>%s</td></tr></table>
<br>
<input type="submit" value="move comments, snippets to new user" />
</form>
""" % (n1, n2, u1.nickname, u2.nickname))
def get(self):
user = users.get_current_user()
prefs = InternalUser.from_user(user)
title = unquote(decode(self.request.get('title')))
code = unquote(decode(self.request.get('code')))
description = decode(self.request.get('desc'))
desc_md = markdown.markdown(unquote(description))
tags = decode(self.request.get('tags'))
values = {"prefs": prefs, "title": title, "code": code, 'desc_md': \
desc_md, 'tags': tags, 'preview': True}
self.response.out.write(template.render(tdir + \
"snippets_edit_view.html", values))
def post(self, snippet_slug):
memcache.incr("ua_edit_snippet", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
title = decode(self.request.get('title'))
code = decode(self.request.get('code'))
description = decode(self.request.get('description'))
tags = decode(self.request.get('tags'))
comment = decode(self.request.get('comment'))
if not title or not code or not description:
self.response.out.write("-1")
return
q = Snippet.all()
q.filter("slug1 =", snippet_slug)
snippet = q.get()
if not snippet:
self.error(404)
return
# Create a new revision
r = SnippetRevision(userprefs=prefs, snippet=snippet)
r.title = title
r.description = description
r.description_md = markdown.markdown(description).replace( \
"<a ", "<a target='_blank' rel='nofollow' ")
r.code = code
r.comment = comment
r.put()
# and not snippet.has_editors:
if prefs.key() == snippet.userprefs.key() or \
prefs.level > 70:
# Auto-merge new revision if edits only by author
r.merge(merged_by=prefs)
else:
# Add proposal info if from another editor
snippet.proposal_count += 1
snippet.date_lastproposal = datetime.datetime.now()
snippet.date_lastactivity = datetime.datetime.now()
snippet.save()
# Set last activity on submitting user
prefs.date_lastactivity = datetime.datetime.now()
prefs.put()
self.redirect("/%s" % snippet_slug)
def get(self, category=None):
if not category or category == "/":
category = "/active"
memcache.incr("pv_main", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
p = decode(self.request.get('p'))
page = int(p) if p else 1
# Get snippets list from cache
#mc.cache.snippet_list(None, clear=True)
snippets = mc.cache.snippet_list(category, page)
# Set title
if category == "/new":
title = "New Snippets"
elif category == "/active":
title = "Active Snippets"
elif category == "/popular":
title = "Popular Snippets"
elif category == "/comments":
title = "Recently Commented Snippets"
elif category == "/edits":
title = "Snippets with Edits"
# Build template
values = {'prefs': prefs, 'snippets': snippets, 'title': title, \
'page': page, 'pages': range(1, page)}
self.response.out.write(template.render(tdir + \
"snippet_list.html", values))
def post(self, comment_key):
comment = SnippetComment.get(db.Key(comment_key))
if not comment:
self.error(404)
return
msg = decode(self.request.get('msg'))
update = decode(self.request.get('update'))
delete = decode(self.request.get('delete'))
if update:
comment.comment = msg
comment.comment_md = markdown.markdown(msg.replace( \
"<a ", "<a target='_blank' rel='nofollow' "))
comment.put()
logging.info("comment updated by admin")
# Update cached comments
mc.cache.snippet_comments(comment.snippet.key(), True)
mc.cache.snippet(comment.snippet.slug1, force_update=True)
self.redirect("/admin/comment/%s" % comment_key)
elif delete:
redirect_to = "/%s" % comment.snippet.slug1
snippet = comment.snippet
comment.delete()
# Update snippet's date_lastcomment
comments = snippet.snippetcomment_set.order("-date_submitted")
comment_last = comments.fetch(1)
if not comment_last:
snippet.date_lastcomment = None
else:
snippet.date_lastcomment = comment_last[0].date_submitted
# Update snippet's comment count
snippet.comment_count -= 1
snippet.put()
mc.cache.snippet_comments(snippet.key(), force_update=True)
mc.cache.snippet(snippet.slug1, force_update=True)
logging.info("comment deleted by admin")
self.redirect(redirect_to)
def try_get(self):
try:
data, addr = self.socket.recvfrom(2**13)
if data:
return tools.decode(data)
else:
return None
except socket.timeout:
return None
def try_get(self):
try:
data, addr = self.socket.recvfrom(2**13)
if data:
return tools.decode(data)
else:
return None
except socket.timeout:
return None
def __init__(self, login, password, relog):
if os.path.exists('user.json') and relog is True:
with open('user.json', 'r') as f:
user_data = json.load(f)
self.login = user_data['login']
self.password = tools.decode(user_data['password'])
else:
self.login = str(login)
self.password = str(password)
def get(self):
memcache.incr("pv_search", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
q = decode(self.request.get('q'))
values = {'prefs': prefs, 'q': q}
self.response.out.write( \
template.render(tdir + "search_results.html", values))
def get(self, snippet_slug):
memcache.incr("pv_snippet", initial_value=0)
memcache.incr("pv_snippet_%s" % snippet_slug, initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
_snippet = mc.cache.snippet(snippet_slug)
if not _snippet:
memcache.incr("pv_snippet_404", initial_value=0)
logging.info("404: %s" % snippet_slug)
# Show snippet-not-found.html
values = {'prefs': prefs, "q": snippet_slug.replace("-", " ")}
self.response.out.write(template.render(tdir + \
"snippets_notfound.html", values))
return
# get count for tags on this snippet
tags = mc.cache.tags_dict()
for tag in _snippet["_tags"]:
if not tag in tags:
tags[tag] = 1
_snippet["tags"].append((tag, tags[tag]))
# if commented and was marked as spam:
commentspam = decode(self.request.get('c')) == "m"
compose_reply = decode(self.request.get('r'))
#logging.info("compose: %s" % compose_reply)
# get cached comments
comments_html = mc.cache.snippet_comments(_snippet["key"])
# get if this user has already voted
has_voted = mc.cache.has_upvoted(prefs, _snippet["key"])
# related snippets
related = mc.cache.snippets_related(snippet_slug)
values = {"prefs": prefs, "snippet": _snippet, 'voted': has_voted,
"comments_html": comments_html, 'commentspam': commentspam, \
"compose_reply": compose_reply, 'related_snippets': related}
self.response.out.write(template.render(tdir + \
"snippets_view.html", values))
def bank_sorter(bank):
"""Sorts bank of tested compounds by fitness and returns all tested compounds and the matches to results_bank."""
keys = np.argsort(bank[:,-1])
for j in range(len(bank)):
# sort the paramterized vectors
sorted_bank[j,:] = bank[keys[j],:]
# call decoder and get symbol
symbol_bank.append(decode(sorted_bank[j,0:3]))
final_bank = [name for name in symbol_bank if (name in results_bank)]
symbol_bank_select = symbol_bank[0:50]
return "all tested = " + str(symbol_bank_select), "matches = " + str(final_bank)
def process_default(self, event):
"""
Called when a new mail is received and placed in Maildir’s new mail
folder.
"""
try:
with open(event.pathname, 'r') as handle:
data = handle.read()
except IOError:
return
message = self._parser.parsestr(data, headersonly=True)
msg_subject = decode(message['Subject'])
msg_from = decode(message['From'])
msg_spam = message['X-Spam-Score'] or ""
try:
msg_spam = float(msg_spam)
except ValueError:
msg_spam = None
if not msg_subject:
msg_subject = u"[Pas de sujet]"
if not msg_from:
msg_from = u"<Pas d’expéditeur>"
result = u">> Mail de %s : %s" % (msg_from, msg_subject)
if msg_spam is not None:
result += u" (Spam Score: %.1f)" % msg_spam
if msg_spam is None or msg_spam < 0.0:
self.bot.say(result)
os.rename(event.pathname, join(self.destpath, event.name))
self.cleanup()
def process_default(self, event):
"""
Called when a new mail is received and placed in Maildir’s new mail
folder.
"""
try:
with open(event.pathname, 'r') as handle:
data = handle.read()
except IOError:
return
message = self._parser.parsestr(data, headersonly=True)
msg_subject = decode(message['Subject'])
msg_from = decode(message['From'])
msg_spam = message['X-Spam-Score'] or ""
try:
msg_spam = float(msg_spam)
except ValueError:
msg_spam = None
if not msg_subject:
msg_subject = u"[Pas de sujet]"
if not msg_from:
msg_from = u"<Pas d’expéditeur>"
result = u">> Mail de %s : %s" % (msg_from, msg_subject)
if msg_spam is not None:
result += u" (Spam Score: %.1f)" % msg_spam
if msg_spam is None or msg_spam < 0.0:
self.bot.say(result)
os.rename(event.pathname, join(self.destpath, event.name))
self.cleanup()
def train(self):
for line in self:
self.i += 1
self.minimum = int(round(math.log(self.i, 10)))
i = 0
for line in self:
tokens = tokenize(decode(line).lower())
targets = self.get_targets(tokens)
for gram in targets:
self.posterior[gram] += 1
self.grams_by_line[i].add(gram)
for token in gram:
self.prior[token] += 1
i += 1
# print self.prior.most_common(10)
# print self.posterior.most_common(10)
self.crunch()
def get(self, snippet_slug, rev_key):
memcache.incr("pv_snippet_edit", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
rev = SnippetRevision.get(rev_key)
#q = db.GqlQuery("SELECT * FROM SnippetRevision WHERE __key__ = :1", \
# db.Key(rev_key))
#rev = q.get() # fetch(1)[0]
if not rev:
self.error(404)
return
# TODO: memcache?
rev.views += 1
rev.put()
has_voted = False
if user:
# see if user has already voted
q1 = db.GqlQuery("SELECT * FROM SnippetRevisionUpvote WHERE \
userprefs = :1 and snippetrevision = :2", prefs, rev)
q2 = db.GqlQuery("SELECT * FROM SnippetRevisionDownvote WHERE \
userprefs = :1 and snippetrevision = :2", prefs, rev)
has_voted = q1.count() or -q2.count() # 0 if not, 1, -1
# Check if user wants to vote
if not has_voted:
has_voted = decode(self.request.get('v'))
if has_voted == "1":
# user wants to upvote
v = SnippetRevisionUpvote(userprefs=prefs, \
snippetrevision=rev)
v.save()
rev.userprefs.points += 1
rev.userprefs.put()
rev.date_lastactivity = datetime.datetime.now()
rev.put()
# Set last activity on voting use0r
prefs.date_lastactivity = datetime.datetime.now()
prefs.put()
elif has_voted == "-1":
# user downvotes
v = SnippetRevisionDownvote(userprefs=prefs, \
snippetrevision=rev)
v.save()
rev.userprefs.points -= 1
rev.userprefs.put()
rev.date_lastactivity = datetime.datetime.now()
rev.save()
# Set last activity on voting use0r
prefs.date_lastactivity = datetime.datetime.now()
prefs.put()
values = {"prefs": prefs, "rev": rev, 'voted': str(has_voted), \
'desc_md': rev.description_md}
self.response.out.write(template.render(tdir + \
"snippets_edit_view.html", values))
def post(self):
user = users.get_current_user()
prefs = InternalUser.from_user(user)
update = decode(self.request.get('update'))
if update == "about":
nickname = decode(self.request.get('nickname'))
email = decode(self.request.get('email'))
twitter = decode(self.request.get('twitter'))
about = decode(self.request.get('about'))
url_addon = ""
if nickname and nickname != prefs.nickname and len(nickname) > 2:
# check if nick is still available, if so then update
q = InternalUser.all()
q.filter("nickname =", nickname)
if q.count():
# already taken
url_addon += "&u=-1"
else:
# free. if email, only own is allowed
if is_valid_email(nickname):
if nickname == prefs.email:
prefs.nickname = nickname
url_addon += "&u=1"
else:
# othre email not permitted
url_addon += "&u=2"
else:
prefs.nickname = nickname
url_addon += "&u=1"
if email and \
((not prefs.email_new and email != prefs.email) or \
(prefs.email_new and email != prefs.email_new)):
if not is_valid_email(email):
self.redirect("/profile?e=-1")
return
# updating email address
if prefs.email_new and email.strip() == prefs.email:
# switching back to already verified mail is ok
prefs.email = email.strip()
prefs.email_new = None
prefs.email_new_code = None
url_addon += "&e=2"
else:
# send verification mail
prefs.email_new = email.strip()
prefs.email_new_code = hashlib.sha1(\
os.urandom(64)).hexdigest()
body_text = template.render(tdir + \
"/email/verify_text.html", \
{'code': prefs.email_new_code, 'email': email})
#print "x"
#print body_text
#return
message = mail.EmailMessage()
message.sender = \
"MOAI Snippets <*****@*****.**>"
message.to = email
message.subject = "MOAI snippets email verification"
message.body = body_text
#message.html = email_body_html
message.send()
url_addon += "&e=1"
if twitter and twitter != prefs.twitter:
prefs.twitter = twitter
url_addon += "&t=1"
if about and about != prefs.about:
prefs.about = about
prefs.about_md = markdown.markdown(about).replace( \
"<a ", "<a target='_blank' ")
url_addon += "&ab=1"
if url_addon:
prefs.put()
prefs.clear_cache()
url_addon = "%s%s" % ("?x=1", url_addon)
self.redirect("/profile%s" % url_addon)
return
if update == "notifications":
# Currently only 4 notification settings. increase as necessary
notifications = 0
for i in xrange(4):
s = decode(self.request.get('n%s' % i))
# n1 = lowest bit, n2 next higher, ...
notifications |= 1 << i if s else 0
#logging.info("= n before: %s" % prefs.notifications)
#logging.info("= n after: %s" % notifications)
url_addon = ""
if notifications != prefs.notifications:
prefs.notifications = notifications
url_addon = "%s%s" % ("&n=1", url_addon)
if url_addon:
prefs.put()
url_addon = "%s%s" % ("?x=1", url_addon)
self.redirect("/profile%s" % url_addon)
return
def get(self):
force_update = decode(self.request.get('n'))
self.response.out.write(mc.cache.sitemap(force_update))
def get_fitness(compound):
"""Computes the fitness of a compound, and returns the negative of it (for function-minimizing)."""
#get inputs to fitness function:
cmpd_name = decode(compound) #finds the name of the compound corresponding to next_point_to_sample
#then query for JSON file with same name
return 0 - eval_fitness_complex_product(json_get(cmpd_name, 'gllbsc_dir-gap'), json_get(cmpd_name, 'gllbsc_ind-gap'), json_get(cmpd_name, 'heat_of_formation_all'), json_get(cmpd_name, 'VB_dir'), json_get(cmpd_name, 'CB_dir'), json_get(cmpd_name, 'VB_ind'), json_get(cmpd_name, 'CB_ind'))
def in_results(compound):
"""Returns a boolean based on whether a compound is in the results_bank."""
name = decode(compound)
return (name in results_bank)
def turn(self) -> (str, int, int):
# Fill these fields to return
message: str = None
message_value: int = 0
direction: int = Direction.CENTER.value
ant = self.game.ant
# print(ant.health)
x = ant.currentX
y = ant.currentY
base_x = self.game.baseX
base_y = self.game.baseY
self.turn_number = self.turn_number + 1
self.init_dirs()
if not self.vision:
# print("Creating vision")
for i in range(self.game.mapWidth):
new_line = []
for j in range(self.game.mapHeight):
new_line.append([(UNKNOWN, -1)])
self.vision.append(new_line)
# self.vision[self.game.mapWidth-base_x-1][self.game.mapHeight-base_y-1].append((ENEMY_BASE, self.turn_number))
cur = self.game.ant.visibleMap.cells[ant.currentX][ant.currentY]
for chat in self.game.chatBox.allChats:
msg = chat.text
for i in range(0, len(msg), 2):
cx, cy, obj = encode(msg[i:i+2])
if not has_obj(obj, self.vision[cx][cy]):
self.vision[cx][cy].append((obj, chat.turn))
new_objs = []
def upd(i, j, obj):
if not has_obj(obj, self.vision[i][j]):
new_objs.append((i, j, obj))
if cur.resource_type == ResourceType.BREAD.value or cur.resource_type == ResourceType.GRASS.value:
tools.last_resource = (x,y)
if cur.type == CellType.TRAP.value and tools.has_resource == 1:
# self.vision[tools.last_resource[0]][tools.last_resource[1]].append((WALL,self.turn_number))
upd(x, y, BAD_TRAP)
self.vision[x][y].append((BAD_TRAP,self.turn_number))
tools.allied_in_range = 0
tools.enemy_in_range = 0
tools.has_resource = 1 if ant.currentResource and ant.currentResource.value > 0 else 0
# print(self.turn_number , " " , tools.has_resource)
if self.turn_number == 0:
random_moves = []
for i in range(self.game.mapWidth):
for j in range(self.game.mapHeight):
cell = self.game.ant.visibleMap.cells[i][j]
if not cell:
continue
if cell.type == CellType.WALL.value:
upd(i, j, WALL)
self.vision[i][j].append((WALL, self.turn_number))
elif cell.type == CellType.TRAP.value:
upd(i, j, TRAP)
if self.turn_number == 0:
random_moves.append(cell)
self.vision[i][j].append((TRAP, self.turn_number))
elif cell.type == CellType.SWAMP.value:
upd(i, j, SWAMP)
self.vision[i][j].append((SWAMP, self.turn_number))
elif cell.type != CellType.EMPTY and cell.type == CellType.BASE.value and (base_x != i or base_y != j): # what
self.vision[i][j].append((ENEMY_BASE, self.turn_number))
else:
if self.turn_number == 0:
random_moves.append(cell)
if cell.resource_type == ResourceType.BREAD.value:
self.vision[i][j].append((BREAD, self.turn_number))
elif cell.resource_type == ResourceType.GRASS.value:
self.vision[i][j].append((GRASS, self.turn_number))
else:
self.vision[i][j].append((EMPTY, self.turn_number))
if cell.ants:
maximum = TEAM_KARGAR
for a in cell.ants:
if a.antType == AntType.KARGAR.value and a.antTeam == AntTeam.ALLIED.value:
this = TEAM_KARGAR
tools.allied_in_range += 0.5
elif a.antType == AntType.SARBAAZ.value and a.antTeam == AntTeam.ALLIED.value:
this = TEAM_SARBAZ
tools.allied_in_range += 1
elif a.antType == AntType.KARGAR.value and a.antTeam == AntTeam.ENEMY.value:
this = ENEMY_KARGAR
tools.enemy_in_range += 0.5
else:
this = ENEMY_SARBAZ
tools.enemy_in_range += 1
if this > maximum:
maximum = this
self.vision[i][j].append((maximum, self.turn_number))
else:
self.vision[i][j].append((NO_ANTS, self.turn_number))
self.vision[i][j] = prune(self.vision[i][j])
if self.turn_number == 0:
print(random_moves)
self.first_target = random.choice(random_moves)
AI.first_target = self.first_target
# print("turn: ", self.turn_number)
set_turn_number(self.turn_number)
if ant.antType == AntType.SARBAAZ.value:
if self.turn_number == 0 and len(cur.ants) > 1:
direction = random.choice([UP,DOWN,LEFT,RIGHT,CENTER])
else:
direction = self.get_move('scorpion')
elif ant.antType == AntType.KARGAR.value:
# if self.turn_number == 0 or self.turn_number == 1:
# direction = random.choice([UP,DOWN,LEFT,RIGHT,CENTER])
# else:
direction = self.get_move('ant')
AI.vision = self.vision
AI.turn_number = self.turn_number
message = ""
message_value = 1
for i, j, obj in new_objs:
message += decode(i, j, obj)
if len(message) > MAX_CHARS:
message = message[:MAX_CHARS]
return message, message_value, direction
def post(self):
"""Check and add new snippet to db"""
user = users.get_current_user()
prefs = InternalUser.from_user(user)
# Validate input
title = self.request.get('title')
code = self.request.get('code')
description = self.request.get('description')
version = self.request.get('version')
tags = []
i = 0
while True:
tag = self.request.get('tag%s' % i)
logging.info("tag: %s" % tag)
if not tag:
break
elif tag == "0":
# 0 is placeholder for removed tag
pass
else:
tags.append(decode(tag))
i += 1
errors = []
if not title:
errors.append("title")
elif len(title) < 16:
errors.append("longer title")
if not code:
errors.append("snippet")
if not description:
errors.append("description")
if len(tags) < 2:
errors.append("a few tags")
if len(errors) > 0:
tags_mostused = mc.cache.tags_mostused()
values = {'prefs': prefs, 'errors': errors, 'title': title, \
'code': code, 'description': description, 'tags': tags, \
'version': version, 'tag_cnt': len(tags), \
"tags_mostused": tags_mostused}
self.response.out.write(template.render(tdir + \
"snippets_new.html", values))
return
# Decode with utf-8 if necessary
title = decode(title.strip())
code = decode(code)
description = decode(description)
# Find a free slug
slug = slugify(title)
_slug = slugify(title)
cnt = 0
while True:
q = Snippet.all()
q.filter("slug1 =", _slug)
if q.count() > 0:
cnt += 1
_slug = u"%s%s" % (slug, cnt + 1)
else:
slug = _slug
break
# Create snippet (submitter is saved only in first revision)
s = Snippet(userprefs=prefs)
s.title = title
s.slug1 = slug
s.description = description
s.description_md = markdown.markdown(description).replace( \
"<a ", "<a target='_blank' rel='nofollow' ")
s.code = code
s.android_minsdk = int(version)
s.put()
# Create the first revision
r = SnippetRevision.create_first_revision(userprefs=prefs, snippet=s)
r.put()
# Create the first upvote
upvote = SnippetUpvote(userprefs=prefs, snippet=s)
upvote.put()
# Create the tags
for tag in tags:
if not tag or len(tag.strip()) < 3:
# skip empty and too short tags
continue
# See if tag base object already exists, if not then create it
q = Tag.all()
q.filter("name =", tag)
t = q.get()
if not t:
t = Tag(name=tag)
t.put()
st = SnippetTag(snippet=s, tag=t)
st.put()
prefs.points += 1
prefs.date_lastactivity = datetime.datetime.now()
prefs.put()
# Clear snippet list cache and have next user rebuild it
mc.cache.snippet_list(None, clear=True)
mc.cache.tags_mostused(force_update=True)
# Trigger background tasks
taskqueue.add(url='/services/update_tags')
taskqueue.add(url='/services/update_sitemap')
taskqueue.add(url='/services/update_relations')
# Prepare Tweet
if not settings.IS_TESTENV:
url = shorturl("http://www.androidsnippets.com/%s" % slug)
max_status_len = 140 - len(url) - 11 # 10 = 2 spaces,:,#android
status = s.title
if len(status) > max_status_len:
status = "%s..." % status[:max_status_len - 3]
status = "%s: %s #android" % (status, url)
logging.info("tweet: '%s' (%s)" % (status, len(status)))
tweet(status)
# Redirect to snippet view
self.redirect("/%s" % s.slug1)
def post(self, snippet_slug):
memcache.incr("ua_comment", initial_value=0)
user = users.get_current_user()
prefs = InternalUser.from_user(user)
# Set last activity on commenting user
prefs.date_lastactivity = datetime.datetime.now()
prefs.put()
q = Snippet.all()
q.filter("slug1 =", snippet_slug)
snippet = q.get()
if not snippet:
self.error(404)
return
comment = decode(self.request.get('comment'))
parent_key = decode(self.request.get('parent_key'))
if not comment or len(comment.strip()) == 0:
self.redirect("/%s" % snippet_slug)
return
if parent_key:
parent = SnippetComment.get(db.Key(parent_key))
logging.info("pk: %s" % parent)
if not parent:
self.error(404)
return
# Add the comment now
c = SnippetComment(userprefs=prefs, snippet=snippet, comment=comment)
c.comment_md = markdown.markdown(comment).replace( \
"<a ", "<a target='_blank' rel='nofollow' ")
if parent_key and parent:
c.parent_comment = parent
# Check if comment is spam
is_spam = False
if not settings.IS_TESTENV:
is_spam = akismet_spamcheck(comment, self.request.remote_addr, \
self.request.headers["User-Agent"])
if is_spam:
memcache.incr("ua_comment_spam", initial_value=1)
logging.warning("= comment: Yup, that's spam alright.")
c.flagged_as_spam = True
url_addon = "?c=m#comments"
else:
memcache.incr("ua_comment_ham", initial_value=1)
url_addon = ""
snippet.comment_count += 1
snippet.date_lastcomment = datetime.datetime.now()
snippet.date_lastactivity = datetime.datetime.now()
snippet.put()
url_addon = ""
# Clear snippet list cache and have next user rebuild it
mc.cache.snippet_list(None, clear=True)
mc.cache.snippet(snippet.slug1, clear=True)
# Save comment now
c.put()
# if not spam, redirect user to see comment
if not url_addon:
url_addon = "#%s" % c.key()
# Recalculate and cache comments
mc.cache.snippet_comments(snippet.key(), True)
self.redirect("/%s%s" % (snippet_slug, url_addon))
