def bitauto_trace(model, deadline):
URL_FORMAT = "http://baa.bitauto.com/{model}/index-all-all-{page}-1.html"
for page in count(1):
url = URL_FORMAT.format(page=page, model=model)
logger.debug("bitauto trace {url}".format(url=url))
content = get_content(url)
d = pq(content)
rows = d("div.postslist_fist_title").nextAll("div.postslist_xh")
for row in rows:
i = pq(row)
title = i("li.bt span").text().strip()
href = i("li.bt a").attr("href")
author = i("li.zz a").html().strip()
now = datetime.datetime.utcnow()
published = (
now.strftime("%Y-%m-%d") if (":" in i("li.zhhf").html().strip()) else i("li.zhhf").html().strip()
)
now = now.strftime("%Y-%m-%dT%H:%M:%SZ")
if published < deadline:
return
yield dict(title=title, href=href, author=author, published=published, insert_dt=now)
def insert_questionnair_records(records):
"""
将读取的问卷记录插入到数据库
Parameters
-----------
records : list
list of QuestionnaireRecord
"""
conn = connect_database()
with conn.cursor() as cur:
for record in records:
sql = 'insert into xy_wenjuan ' \
'(barcode, lbcode, lbname, qcode, question, answer) ' \
'VALUES ' \
'(\'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\')' % (
record.tjid,
record.lbbm,
record.lbmc,
record.qcode,
record.question,
record.answer,
)
try:
logger.debug(sql)
cur.execute(sql)
except:
logger.warn(
'Insertion fail when trying to insert %s!' % record.line
)
conn.commit()
def get_content(url):
r = requests.get(url, headers={"User-Agent": random.choice(USER_AGENTS)})
assert r.status_code == 200
if r.encoding in ("ISO-8859-1", "gb2312"):
logger.debug("Turn coding from {coding} to gbk".format(coding=r.encoding))
r.encoding = "gbk"
return r.text
def post_vote():
user = current_user
if not request.json or not 'talkId' in request.json:
abort(400)
talkId = request.json['talkId']
try:
vote = db.session.query(Vote).filter(Vote.talkId==talkId).filter(Vote.email==user.email).first()
except:
logger.error("Unexpected error loading the vote:", sys.exc_info()[0])
raise
try:
if vote == None:
vote = Vote()
vote.talkId = talkId
vote.email = user.email
vote.fitsTechfest = request.json['fitsTechfest']
vote.fitsTrack = request.json['fitsTrack']
vote.expectedAttendance = request.json['expectedAttendance']
db.session.add(vote)
db.session.commit()
logger.debug('User {} voted on talkId {} - {}/{}/{}.'.format(user.email,
talkId, vote.fitsTechfest, vote.fitsTrack, vote.expectedAttendance))
except:
logger.error("Unexpected error saving the vote:", sys.exc_info()[0])
raise
return json.dumps(vote.serialize), 201
def wait_for_operation(project, zone, operation):
"""
Checks if operation demanded (create/start/stop/delete) is completed
:param project: Project name on google cloud
:param zone: zone the vm_instance resides in
:param operation: which operation is being run
:return: True when completed
"""
logger.debug('Waiting for operation to finish...')
while True:
try:
compute = discovery.build('compute', 'v1', credentials=get_compute_engine_credentials())
req = compute.zoneOperations().get(
project=project,
zone=zone,
operation=operation
)
result = req.execute()
if result['status'] == 'DONE':
return result['status']
time.sleep(1)
except Exception as e:
logger.debug('Checking if operation is completed failed: %s' % e)
def create_disk_for_vm(name, source_image, disk_size, zone=DEFAULT_VM_ZONE, project=PROJECT_NAME):
"""
Creates disk on Google Cloud compute engine to be used alongside a vm. Disk is generated from
an image that is also stored on Google Cloud compute engine
:param name: Name of disk (Usually same name as VM_name)
:param source_image: Image for disk to replicate (stored on google cloud compute engine/ images)
:param disk_size: Size of disk
:param zone: The zone the disk should be created in (same as VM zone)
:param project: Name of project
:return: Link of disk if successful, False if unsuccessful
"""
try:
compute = discovery.build('compute', 'v1', credentials=get_compute_engine_credentials())
config = {
'name': name,
'description': '',
'sizeGb': disk_size,
'sourceImage': source_image,
}
req = compute.disks().insert(project=project, zone=zone, body=config)
resp = req.execute()
completed = wait_for_operation(project, zone, resp['name'])
if completed == 'DONE':
link = resp['targetLink'].split('/v1/')[1]
return link
except Exception as e:
logger.debug("Creation of disk failed: %s" % e)
print(e)
return False
def get_votes():
user = current_user
logger.debug('Getting votes for user {}.'.format(user.email))
sys.stdout.flush()
items = Vote.query.filter(Vote.email==user.email).all()
logger.debug('Found {} votes entered by user {}.'.format(len(items), user.email))
return Response(json.dumps([item.serialize for item in items]), mimetype='application/json')
def autohome_trace(model, deadline):
URL_FORMAT = 'http://club.autohome.com.cn/bbs/forum-c-{model}-{page}.html?orderby=dateline&qaType=-1'
BASE_URL = 'http://club.autohome.com.cn'
for page in count(1):
url = URL_FORMAT.format(page=page, model=model)
logger.debug('autohome trace {url}'.format(url=url))
content = get_content(url)
d = pq(content)
rows = d('dl.bluebg:last').nextAll('dl.list_dl')
for row in rows:
i = pq(row)
title = i('dt a').html().strip()
href = BASE_URL + i('dt a').attr('href')
author = i('dd:eq(0) a').html()
published = i('dd:eq(0) span.tdate').html()
now = datetime.datetime.utcnow()
now = now.strftime('%Y-%m-%dT%H:%M:%SZ')
if published < deadline:
return
yield dict(title=title, href=href, author=author, published=published, insert_dt=now)
def bitauto_trace(model, deadline):
URL_FORMAT = 'http://baa.bitauto.com/{model}/index-all-all-{page}-1.html'
for page in count(1):
url = URL_FORMAT.format(page=page, model=model)
logger.debug('bitauto trace {url}'.format(url=url))
content = get_content(url)
d = pq(content)
rows = d('div.postslist_fist_title').nextAll('div.postslist_xh')
for row in rows:
i = pq(row)
title = i('li.bt span').text().strip()
href = i('li.bt a').attr('href')
author = i('li.zz a').html().strip()
now = datetime.datetime.utcnow()
published = now.strftime(
'%Y-%m-%d') if (':' in i('li.zhhf').html().strip()) else i('li.zhhf').html().strip()
now = now.strftime('%Y-%m-%dT%H:%M:%SZ')
if published < deadline:
return
yield dict(title=title, href=href, author=author, published=published, insert_dt=now)
def compute_hiperspaces(self):
# La característica heurística al buscar conexiones entre
# diferentes clusters hace que pueda fallar
# por lo que redirigimos la salida para ser silenciosos
# en esos casos
if not len(self.points) > 0:
logger.error('No points to compute hull!')
raise Exception('No points to compute hull!')
stderr_fd = sys.stderr.fileno()
with open('/tmp/qhull-output.log', 'w') as f, stderr_redirected(f):
points = list(self.points)
logger.info('Searching for hull in dimension %s based on %s points',
len(points[0]),len(points))
output = qconvex('n',points)
if len(output) == 1:
logger.debug('Could not get Hull. Joggle input?')
try:
dim, facets_nbr, facets = self.__parse_hs_output(output)
except IncorrectOutput:
logger.warning('Could not get hull')
raise CannotGetHull()
logger.info('Found hull in dimension %s of %s facets',
dim,len(facets))
self.dim = dim
self.facets = facets
if self.verbose:
print "Computed MCH with ",facets_nbr," halfspaces"
print 'This are them:\n'
for facet in self.facets:print facet
return self.dim
def upload_file(local_path, remote_name, bucket=STORAGE_BUCKET):
"""
Upload a file to Google Storage
:param local_path: The local path to the file to upload
:param remote_name: The name of the file in the google cloud storage
:param bucket: The bucket on google cloud storage you want to upload the file to
:return: True if uploaded, False otherwise
"""
try:
service = discovery.build('storage', 'v1', credentials=get_storage_credentials())
logger.info("Uploading %s to google cloud" % local_path)
req = service.objects().insert(
bucket=bucket,
name=remote_name,
# predefinedAcl="publicRead", Uncomment this line if you want your files to be accessible to anyone
media_body=local_path)
req.execute()
uploaded = check_if_file_exists(remote_name)
if uploaded is True:
logger.info("Upload complete!")
return True
else:
return False
except Exception as e:
logger.debug("Unable to upload file %s to google cloud: %s" % (local_path, e))
return False
def check(self, suggested, data):
"""Return list of tags from 'suggested': first is list of tags that
passes checks and second is dict of tags whose check(s) did not
passed (key is tag name and value is why it failed)."""
passed = set()
failed = {}
# Execute all relavant checks and store its results in 'results' dict
results = {}
suggested_set = set(suggested)
relevant_mods = [mod for mod in self.checks if not set(mod.tags).isdisjoint(suggested_set)]
for mod in relevant_mods:
result = None
try:
results[mod.__name__] = {'out': mod.main(data), 'tags': mod.tags, 'desc': mod.desc}
except:
logger.exception('Something failed')
logger.debug("Check %s returned %s" % (mod.__name__, result))
# Now take the results of individual checks and compile lists of passed
# and failed tags
for result in results.itervalues():
if result["out"]:
for tag in result["tags"]:
passed.add(tag)
else:
for tag in result["tags"]:
failed.setdefault(tag, list()).append(result["desc"])
return passed, failed
def get_webinar_info(input_file, details_mark):
"""
Gather information about the webinar
:input: a csv file of attendees for a GotoWebinar to read from
:return: a list of two lists containing the webinar details
headers and corresponding header values
"""
try:
with open(input_file, 'rb') as csv_file:
rdr = reader(csv_file)
# read Generated info and advance to next useful headers
rdr.next()
keys = rdr.next()
vals = rdr.next()
rdr.next()
# read the rest of webinar info
while details_mark not in keys:
try:
headers += clear_empty_from_list(keys)
values += clear_empty_from_list(vals)
except NameError:
headers = clear_empty_from_list(keys)
values = clear_empty_from_list(vals)
keys = rdr.next()
vals = rdr.next()
return [headers, values]
except IOError as e:
logger.error("Cannot read file '{}'".format(input_file))
logger.debug("Exception:\n{}".format(e))
def get_participants_info(input_file, webinar_id, details_mark):
"""
Gather information about the webinar participants
:input: a csv file of attendees for a GotoWebinar to read from
the webinar id number
:return: a list of two lists containing the webinar participants
details headers and a list of items representing corresponding
header values
"""
reading_details = 0
values_list = []
remove_row_marker = '*If an attendee left and rejoined the session, the In Session Duration column only includes their first visit.'
try:
with open(input_file, 'rb') as csv_file:
rdr = reader(csv_file)
for row in rdr:
if not reading_details:
if details_mark in row:
headers = ['Webinar ID'] + rdr.next()
reading_details = 1
continue
elif remove_row_marker not in row:
values_list.append([webinar_id] + row)
return [headers, values_list]
except IOError as e:
logger.error("Cannot read file '{}'".format(input_file))
logger.debug("Exception:\n{}".format(e))
def compute_hiperspaces(self):
if not len(self.points) > 0:
logger.error('No points to compute hull!')
raise Exception('No points to compute hull!')
# The heuristic caracteristic when searching to connect
# different clusters does that it might fail
# so we redirect the stdout to avoid such error
# being visible to user
stderr_fd = sys.stderr.fileno()
with open('/tmp/qhull-output.log', 'w') as f, stderr_redirected(f):
points = list(self.points)
logger.info('Searching for hull in dimension %s based on %s points',
len(points[0]),len(points))
output = qconvex('n',points)
if len(output) == 1:
logger.debug('Could not get Hull. Joggle input?')
try:
dim, facets_nbr, facets = self.__parse_hs_output(output)
except IncorrectOutput:
logger.error('Could not get hull')
raise CannotGetHull()
logger.info('Found hull in dimension %s of %s facets',
dim,facets_nbr)
self.dim = dim
self.facets = facets
return self.dim
def read_prototype(celltype, cdict):
"""Read the cell prototype file for the specified class. The
channel properties are updated using values in cdict."""
filename = '%s/%s.p' % (config.modelSettings.protodir, celltype)
logger.debug('Reading prototype file %s' % (filename))
adjust_chanlib(cdict)
cellpath = '%s/%s' % (config.modelSettings.libpath, celltype)
if moose.exists(cellpath):
return moose.element(cellpath)
for handler in logger.handlers:
handler.flush()
proto = moose.loadModel(filename, cellpath)
# If prototype files do not have absolute compartment positions,
# set the compartment postions to origin. This will avoid
# incorrect assignemnt of position when the x/y/z values in
# prototype file is just to for setting the compartment length.
if not config.modelSettings.morph_has_postion:
for comp in moose.wildcardFind('%s/#[TYPE=Compartment]' % (proto.path)):
comp.x = 0.0
comp.y = 0.0
comp.z = 0.0
leveldict = read_keyvals('%s/%s.levels' % (config.modelSettings.protodir, celltype))
depths = read_keyvals('%s/%s.depths' % (config.modelSettings.protodir, celltype))
depthdict = {}
for level, depthset in list(depths.items()):
if len(depthset) != 1:
raise Exception('Depth set must have only one entry.')
depthdict[level] = depthset.pop()
assign_depths(proto, depthdict, leveldict)
config.logger.debug('Read %s with %d compartments' % (celltype, len(moose.wildcardFind('%s/#[TYPE=Compartment]' % (proto.path)))))
return proto
def get_qhull(self, neg_points=[]):
""" From a Petrinet, gets it's representationas a Convex Hull
"""
# Create an empty Convex Hull
qhull = Qhull(neg_points=neg_points)
# La normal por defaul para cada facet
dim = len(self.transitions)
tmpl_normal = [0]*dim
# Each transition corresponds to one dimension
# transition.label -> dimension number
transitions = self.event_dictionary
# Each facet corresponds to one place
# place.id -> {normal->[arc.value], offset->marking}
facets_dict = {}
# Iteramos sobre los arcos
for arc in self.arcs:
# No debería haber arcos nulos
if not arc.value:
logger.error('We found a zero arc: %s',arc)
raise Exception('We found a zero arc: %s',arc)
# NOTE recordar que nuestra representación interna de HS es
# al revés que el paper (usamos <= 0 en lguar de >= 0)
if isinstance(arc.source,Transition):
# Si el arco sale de una transition el coeficiente es < 0
coef = -1*arc.value
transition = arc.source
place = arc.destination
else:
# Si el arco sale de un place el coeficiente es > 0
coef = arc.value
place = arc.source
transition = arc.destination
x = transitions.setdefault(transition.label,len(transitions))
facet = facets_dict.setdefault(place.id,{'normal':list(tmpl_normal),
'in_transitions':[],
'out_transitions':[],
'offset': -1*place.marking,
'id':place.id})
if coef < 0:
facet['in_transitions'].append(transition.label)
else:
facet['out_transitions'].append(transition.label)
if facet['normal'][x]:
logger.debug('Coeficient already loaded. Dummy place')
coef = 0
facet['normal'][x] = coef
facets = []
for pl_id, facet in facets_dict.items():
# Do not create the facet for dummy places
if not any(facet['normal']):
continue
# Values are always integer
hs = Halfspace(facet['normal'], facet['offset'], integer_vals=False)
logger.debug('Adding facet %s',hs)
facets.append(hs)
qhull.dim = dim
qhull.facets = facets
return qhull
def get_content(url):
r = requests.get(url, headers={'User-Agent': random.choice(USER_AGENTS)})
assert r.status_code == 200
if r.encoding in ('ISO-8859-1', 'gb2312'):
logger.debug(
'Turn coding from {coding} to gbk'.format(coding=r.encoding))
r.encoding = 'gbk'
return r.text
def process_csv_info():
"""
Processes the read information:
Separate headers form webinars and participants details.
Detect differences in participants headers and cope with them
( keep the longes header and add empty fields in the right
positionfor participants info rows that are shorter than
the longest header )
Basic error checking and debug messahe logging.
:return: 1 on error and 0 on success
"""
global w_dict, w_header, w_values, w_info
global p_header, p_values, p_headers_list
# get headers and values for webinars
w_header = w_info[0]
w_values = []
for key in w_dict:
w_values += w_dict[key]
# get headers and values for participants
p_header, p_values, diffs = p_headers_list[0], [], []
for h in p_headers_list[1:]:
# try to find differences in participants headers
if len(p_header) < len(h):
diffs = [x for x in h if x not in p_header]
p_header = h
break
elif len(h) < len(p_header):
diffs = [x for x in p_header if x not in h]
break
if diffs:
diffs_pos = [p_header.index(x) for x in diffs]
for key in p_dict:
for row in p_dict[key]:
if len(row) < len(p_header):
# handle differences in input files headers
if not diffs:
logger.error("Header longer than row but no diffs detected.")
return 1
for pos in diffs_pos:
insert_pos = int(pos)
row.insert(insert_pos, "")
elif len(row) > len(p_header):
logger.error("Participants row longer than header.Exiting...")
logger.debug('''
webinar id:{}
final_participants_header:{}
row:{}
'''.format(key, p_header, row))
return 1
else:
break
p_values += p_dict[key]
return 0
def init():
models = [m.User,m.Post,m.Image,m.Comment,m.BlogData]
for t in reversed(models):
logger.debug("Dropping %s" % t)
t.drop_table(True)
for t in models:
logger.debug("Creating {}.\n\tColumns: {}".format(
t, ", ".join(t._meta.columns.keys())))
t.create_table(True)
def emit(self, *args, **kwargs):
if len(args) != len(self.args):
raise ValueError('incorrect amount of arguments {} for signal {}'.format(repr(args), repr(self.name)))
for handler in self.__handlers:
#try:
logger.debug('firing {} for {}'.format(self, handler))
handler(*args, **kwargs)
def list_vm_instances(project=PROJECT_NAME, zone=DEFAULT_VM_ZONE):
try:
compute = discovery.build('compute', 'v1', credentials=get_compute_engine_credentials())
req = compute.instances().list(project=project, zone=zone)
response = req.execute()
print(json.dumps(response['items'], indent='\n'))
return response
except Exception as e:
logger.debug("Unable to list instances: %s" % e)
def build_url(self, hostname, ipaddr):
qstring = urlencode({"hostname": hostname,
"myip": ipaddr,
"wildcard": "NOCHG",
"mx": "NOCHG",
"backmx": "NOCHG"})
upd_url = "%(url)s?%(qstring)s" % {"url": URL_UPDATE,
"qstring": qstring}
logger.debug("Built url: %s", upd_url)
return upd_url
def run(self, tags, rules, data):
"""Run rules (run all when "rules" is empty, othervise run only these
listed there) and return dict with their answers"""
results = []
for mod in self.rules:
# Skip rule if we are supposed to run only specific rules and this
# one is not the choosen one
if len(rules) > 0 and mod.__name__ not in rules:
logger.debug("Skipping %s because only specific rules are supposed to run" % mod.__name__)
continue
# Skip this rule if there is no intersection of tags we should run
# and tags this rule should be run for
if len([val for val in tags if val in mod.tags]) == 0:
logger.debug("Skipping %s because it is not tagged with provided tags" % mod.__name__)
continue
# Finally run the rule
func = getattr(mod, 'main')
func_text = getattr(mod, 'text')
name = getattr(mod, 'name')
result = None
used = []
text = ''
# Reset list of data rule used
data.reset_access_list()
# Now run the rule
try:
result = func(data)
except DataNotAvailable:
logger.error("Data not available for %s" % mod.__name__)
result = False
except:
logger.exception("Something failed badly when executing %s" % mod.__name__)
result = False
logger.info("Rule %s returned %s" % (mod.__name__, result))
# Store list of data rule has used
used = data.get_access_list()
# Now if necessary, get description of whats wrong
if result:
try:
text = func_text(result)
except:
logger.exception("Something failed badly when getting description for %s" % mod.__name__)
# Determine what the result was
if result:
status = 'FAIL'
elif result is False:
status = 'SKIP'
elif result is None:
status = 'PASS'
else:
logger.error("Failed to understand to result of %s" % result)
continue
# Save what was returned
results.append({'label': mod.__name__, 'status': status, 'result': result, 'name': name, 'text': text, 'used': used})
return results
def start_volatile_status(battle, split_msg):
if is_opponent(battle, split_msg):
pkmn = battle.opponent.active
else:
pkmn = battle.user.active
volatile_status = normalize_name(split_msg[3].split(":")[-1])
if volatile_status not in pkmn.volatile_statuses:
logger.debug("Starting the volatile status {} on {}".format(
volatile_status, pkmn.name))
pkmn.volatile_statuses.append(volatile_status)
def singleturn(battle, split_msg):
if is_opponent(battle, split_msg):
side = battle.opponent
else:
side = battle.user
move_name = normalize_name(split_msg[3].split(':')[-1])
if move_name in constants.PROTECT_VOLATILE_STATUSES:
# set to 2 because the `upkeep` function will decrement by 1 on every end-of-turn
side.side_conditions[constants.PROTECT] = 2
logger.debug("{} used protect".format(side.active.name))
def startPythm():
"""Start the Pythm and renice if it was requested
"""
config = PythmConfig()
renice_level = config.get("pythm", "renice", default=-5, dtype=int)
if renice_level != 0:
logger.debug("Renicing pythm to %d" % renice_level)
try:
os.nice(renice_level)
except OSError, e:
logger.error("Failed to renice: %s" % e)
def fieldend(battle, split_msg):
"""Remove the battle's field condition"""
field_name = normalize_name(split_msg[2].split(':')[-1].strip())
# trick room shows up as a `-fieldend` item but is separate from the other fields
if field_name == constants.TRICK_ROOM:
logger.debug("Removing trick room")
battle.trick_room = False
else:
logger.debug("Setting the field to None")
battle.field = None
def fieldstart(battle, split_msg):
"""Set the battle's field condition"""
field_name = normalize_name(split_msg[2].split(':')[-1].strip())
# trick room shows up as a `-fieldstart` item but is separate from the other fields
if field_name == constants.TRICK_ROOM:
logger.debug("Setting trickroom")
battle.trick_room = True
else:
logger.debug("Setting the field to {}".format(field_name))
battle.field = field_name
def sideend(battle, split_msg):
"""Remove a side effect such as stealth rock or sticky web"""
condition = split_msg[3].split(':')[-1].strip()
condition = normalize_name(condition)
if is_opponent(battle, split_msg):
logger.debug("Side condition {} ending for opponent".format(condition))
battle.opponent.side_conditions[condition] = 0
else:
logger.debug("Side condition {} ending for bot".format(condition))
battle.user.side_conditions[condition] = 0
def make_move(self, level, player, monster):
if monster.has_condition('paralyzed'):
return
if monster.has_condition('asleep'):
if self._should_wake_up(level, player, monster):
monster.clear_condition('asleep')
return True
level.set_fov(monster)
m_tile = level.tile_for(monster)
p_tile = level.tile_for(player)
# if we can fight
if hasattr(monster.actions, 'melee'):
# if were next to player then attack
#FIXME being_distance seems to be high by 1
if level.being_distance(player, monster) < 2:
logger.debug('The {} on {} melees with you.'.format(monster, m_tile))
monster.actions.melee(p_tile)
return True
# if we cant even move give up
if not hasattr(monster.actions, 'move'):
return False
#chase if we are not confused
if not monster.has_condition('confused'):
logger.debug('The {} on {} is chasing you.'.format(monster, m_tile))
tile = level.chase_player(monster)
else:
tile = None
# if we cant chase move randomly
if not tile:
logger.debug('The {} on {} could not chase you.'.format(monster, m_tile))
tile = self._random_walk(player, level, monster)
# if we cant move giveup
if not tile:
logger.debug('The {} on {} could not find a tile to move to.'.format(monster, m_tile))
return False
# dont attack other monsters
if tile.being:
logger.debug('The {} on {} tried to attack another monster.'.format(monster, m_tile))
return False
# else just move to the square
else:
monster.actions.move(tile)
return True
async def get_balance(self):
method = 'GET'
url_path = '/account/v1/balance'
headers = self.generate_headers(method, url_path)
url = API_URL + url_path
response = await self.api_call(url, method, headers)
if 'usd' in response:
self.balance = Balance(**response).usd
logger.debug(f'BALANCE: {self.balance}')
return self.balance
else:
logger.debug(f'{response}')
def post(self):
json_data = request.json
if 'payload' in json_data:
payload = json_data['payload']
logger.debug(payload)
#TODO Handle quality checking and save to db.
item = payload
data_item.save_item(item)
return "Not today."
else:
logger.warning("No payload in post json data.")
return "Not here."
def delete(self, id):
session = Session()
username = oidc.user_getfield('username')
grant = session.query(RoleGrant).get(id)
if not grant:
json_abort(404)
if not grant.topic.user == username:
json_abort(403)
session.delete(grant)
session.commit()
logger.debug(grant)
return jsonify(grant)
async def update_base(self):
final_skins = list()
for game in GAMES:
logger.debug(game)
skins = await self.get_items(self.min_price, self.max_price, game)
skins = [
s for s in skins if not self.select_skin.skin_existence(s)
]
final_skins += await self.filter_skins(skins, self.min_price,
self.max_price)
self.select_skin.create_all_skins(final_skins)
logger.info(f'Всего проанализировано скинов: {len(final_skins)}')
def status(battle, split_msg):
if is_opponent(battle, split_msg):
pkmn = battle.opponent.active
else:
pkmn = battle.user.active
if len(split_msg) > 4 and 'item: ' in split_msg[4]:
pkmn.item = normalize_name(split_msg[4].split('item:')[-1])
status_name = split_msg[3].strip()
logger.debug("{} got status: {}".format(pkmn.name, status_name))
pkmn.status = status_name
def __load_config(self):
"""Loads mapping of label to actual command in case we are running on live
system and label to possible files in case we are running from dump."""
config = ConfigParser.SafeConfigParser()
config.optionxform = str
config.read(self.__config_filename)
self.config = {}
self.config['commands'] = dict(config.items(self.__config_commands_section))
self.config['files'] = {}
for k, v in dict(config.items(self.__config_files_section)).iteritems():
self.config['files'][k] = v.splitlines()
logger.debug("Loaded commands and files config %s" % self.config)
def get_profile_from_id(instance_session, instance_url, instance_key, instance_profile, instance_name=''):
instance_profiles = get_quality_profiles(instance_session=instance_session, instance_url=instance_url, instance_key=instance_key)
profile = next((item for item in instance_profiles if item["name"].lower() == instance_profile.lower()), False)
if not profile:
logger.error('Could not find profile_id for instance {} profile {}'.format(instance_name, instance_profile))
exit_system()
instance_profile_id = profile.get('id')
logger.debug(f'found profile_id (instance{instance_name}) "{instance_profile_id}" from profile "{instance_profile}"')
return instance_profile_id
def inactive(battle, split_msg):
regex_string = "(\d+) sec this turn"
if split_msg[2].startswith(constants.TIME_LEFT):
capture = re.search(regex_string, split_msg[2])
try:
battle.time_remaining = int(capture.group(1))
logger.debug("Time remaining: {}".format(capture.group(1)))
except ValueError:
logger.warning("{} is not a valid int".format(capture.group(1)))
except AttributeError:
logger.warning("'{}' does not match the regex '{}'".format(
split_msg[2], regex_string))
def _on_failure(self):
'''
Increments failure counter and switches state if allowed_fails is
reached
'''
self._failure_count += 1
logger.debug("Failure encountered, failure count: {}".format(
self._failure_count))
if self._failure_count >= self._allowed_fails:
current_state = self._check_state()
if current_state != OPEN:
self._open()
def startServer(socket, host, port):
# bind to the given socket to begin listening
# for connections
try:
socket.bind((config.host, port))
socket.listen(config.queue_length)
l.debug("Server started at '%s' : %d", host, port,
extra={'host' : config.host, 'id' : 0})
return True, None
except Exception as e:
print("Server failed to started", str(e))
return False, e.errno
def view():
global PROJECT_DIR
ret = {}
logger.info('project view : view')
for root, dirs, files in os.walk(PROJECT_DIR):
for file in files:
if file[-7:] == '.pickle':
with open(os.path.join(root, file), 'rb') as f:
pj = pickle.load(f)
ret[file[:-7]] = pj
logger.debug('project view return : {}'.format(ret))
return ret
async def pokemon_battle(ps_websocket_client, pokemon_battle_type):
battle = await start_battle(ps_websocket_client, pokemon_battle_type)
chatted = False
while True:
msg = await ps_websocket_client.receive_message()
if battle_is_finished(msg):
winner = msg.split(constants.WIN_STRING)[-1].split('\n')[0].strip()
logger.debug("Winner: {}".format(winner))
await ps_websocket_client.send_message(battle.battle_tag, [config.battle_ending_message])
await ps_websocket_client.leave_battle(battle.battle_tag, save_replay=config.save_replay)
return winner
else:
action_required = await async_update_battle(battle, msg)
if action_required and not battle.wait:
best_move = await async_pick_move(battle)
playerSide = battle.user
opponentSide = battle.opponent
pCount = 6;
oCount = 6;
score=5
for pkm in opponentSide.reserve:
if pkm.hp==0:
oCount-=1
for pkm in playerSide.reserve:
if pkm.hp==0:
pCount-=1
if pCount == 1 and oCount == 1:
score= 0
if oCount == 1:
score= 1
if pCount == 1:
score = 2
if pCount >= oCount+3:
score=3
if chatted:
pass
elif score == 0: # both sides have one pokemon left
chatted = True
await ps_websocket_client.send_message(battle.battle_tag, ['Close game!'])
elif score == 1: # opponent has one pokemon left
chatted = True
await ps_websocket_client.send_message(battle.battle_tag, ['Nice try, guy.'])
elif score == 2: # player has one pokemon left
chatted = True
await ps_websocket_client.send_message(battle.battle_tag, ['Please forfeit :c'])
elif score == 3: # player has three more Pokemon than the opponent
chatted = True
await ps_websocket_client.send_message(battle.battle_tag, ['I must be playing against a bot.'])
await ps_websocket_client.send_message(battle.battle_tag, best_move)
def check_choice_band_or_specs(battle, damage_dealt):
if (
battle.opponent.active is None or
battle.opponent.active.item != constants.UNKNOWN_ITEM or
damage_dealt.crit or
damage_dealt.move in constants.WEIGHT_BASED_MOVES or
damage_dealt.move in constants.SPEED_BASED_MOVES or
not battle.opponent.active.can_have_choice_item
):
return
try:
move_dict = all_move_json[damage_dealt.move]
except KeyError:
logger.debug("Could not find the move {}, skipping choice item check".format(move))
return
if move_dict[constants.CATEGORY] == constants.PHYSICAL:
choice_item = 'choiceband'
spread = 'adamant', '0,252,0,0,0,0'
elif move_dict[constants.CATEGORY] == constants.SPECIAL:
choice_item = 'choicespecs'
spread = 'modest', '0,0,0,252,0,0'
else:
# don't guess anything if the move was neither physical nor special
return
if battle.battle_type == constants.RANDOM_BATTLE:
spread = 'serious', '85,85,85,85,85,85'
max_damage = float('-inf')
potential_battles = battle.prepare_battles(guess_mega_evo_opponent=False, join_moves_together=True)
battle_copy = deepcopy(battle)
battle_copy.user.from_json(battle.request_json)
for b in potential_battles:
if b.opponent.active.item != choice_item:
b.opponent.active.set_spread(*spread)
b.user.active.stats = battle_copy.user.active.stats
state = b.create_state()
damage = calculate_damage(state, constants.OPPONENT, damage_dealt.move, battle.user.last_used_move.move, calc_type='max')[0]
max_damage = max(max_damage, damage)
# dont infer if we did not find a damage amount
if max_damage == float('-inf'):
return
if (damage_dealt.percent_damage * battle.user.active.max_hp) > (max_damage * 1.2): # multiply to avoid rounding errors
logger.debug("{} has {}".format(battle.opponent.active.name, choice_item))
battle.opponent.active.item = choice_item
async def parse_message(ps_websocket_client, msg, battles):
split_msg = msg.split('|')
if split_msg[1].strip() == 'updatechallenges':
await ps_websocket_client.accept_challenge(split_msg, battles)
return
if split_msg[1].strip() == 'init' and split_msg[2].strip() == 'battle':
battle = None
for curr in battles:
if curr.battle_tag == 'pending':
battle = curr
battle.battle_tag = split_msg[0].replace('>', '').strip()
user_name = split_msg[-1].replace('☆', '').strip()
battle.opponent.account_name = split_msg[4].replace(
user_name, '').replace('vs.', '').strip()
battle.opponent.name = 'pending'
break
if battle == None:
logger.debug("ERROR: can't find pending slot")
return
if 'battle' in split_msg[0]:
battle = None
i = 0
for curr in battles:
if curr.battle_tag == split_msg[0].replace('>', '').strip():
battle = curr
break
i += 1
if battle == None:
logger.debug("ERROR: can't find battle slot")
return
if battle.opponent.name == 'pending':
await initialize_battle(ps_websocket_client, battle, split_msg)
elif battle.started == False:
if battle.battle_type == constants.STANDARD_BATTLE:
await run_start_standard_battle(ps_websocket_client, battle,
msg)
return
else:
await run_start_random_battle(ps_websocket_client, battle, msg)
return
else:
ended = await pokemon_battle(ps_websocket_client, battle, msg)
if (ended):
battles[i] = Battle('empty')
return
if split_msg[1].strip() == 'pm' and '$' in split_msg[4]:
await ps_websocket_client.parse_command(split_msg, battles)
return
def get_statuses_list(account_id: int):
response = requests.get(
url=base_url + '/account/{account_id}/vacancy/statuses'.format(
account_id=account_id),
headers=default_headers)
logger.debug(json.loads(response.text))
if response.status_code == 200:
return response.json()
else:
raise Exception(response)
def __init__(self,classdec):
"""
input:
- classdec: java ast aterm for this class
stores following info about class:
.name classname
.decorators : ["public","static",...]
"""
self.name = str(classdec.ClassDecHead[1])
logger.debug("Java_Class.__init__ %s",self.name)
#logger.debug(pp_aterm(classdec))
self.decorators = decorators(classdec.ClassDecHead[0])
def get_me():
"""
Получение информации о пользователе.
:return: Response object
"""
response = requests.get(base_url + '/me', headers=default_headers)
logger.debug(json.loads(response.text))
if response.status_code == 200:
return response
else:
raise Exception('Error when try connect to API.')
def pach(self):
logger.debug('Starting parsing')
self.parse()
logger.debug('Starting modeling')
self.model()
# Remove unnecesary facets wrt neg traces (if any)
self.no_smt_simplify()
# Remove unnecesary facets wrt neg traces
# Apply smt_simplify.
# Options are on the hull level, on every facet or none
self.smt_simplify()
self.generate_output_file()
return self.complexity
def _ensure_request_json(self) -> None:
if not self.url.endswith(".json"):
dot_position = self.url.rfind(".")
if dot_position > 0:
self.url = self.url.replace(self.url[dot_position:], ".json")
else:
self.url = f"{self.url}.json"
logger.warning(
"URL suffix adjusted to a supported format. "
"For more details see: "
"https://config-client.amenezes.net/docs/1.-overview/#default-values"
)
logger.debug(f"Target URL configured: {self.url}")
async def receive_message(self):
message = await self.websocket.recv()
# check to see if we have a chat message and if we're tracking messages
if "\n\n|c|" in message and config.track_chat == "True":
chatRegex = re.compile('\\n\\n\|c\|(.+)\\n$')
chatSearch = chatRegex.search(message)
with open("chatMessages.txt", "a") as f:
try:
f.write(chatSearch.group(1) + '\n')
except:
f.write(f"ERROR: COULD NOT PARSE THIS MESSAGE:{message}\n")
logger.debug("Received from websocket: {}".format(message))
return message
def dispatch(intent_request):
"""
Called when the user specifies an intent for this bot.
"""
logger.debug('dispatch userId={}, intentName={}'.format(
intent_request['userId'], intent_request['currentIntent']['name']))
intent_name = intent_request['currentIntent']['name']
# Dispatch to your bot's intent handlers
try:
return intent_functions[intent_name](intent_request)
except KeyError:
raise Exception('Intent with name ' + intent_name + ' not supported')
def Delete(self, table, cond=None):
self.lock.acquire()
statement = 'DELETE FROM %s' % table
if cond:
statement += ' WHERE %s' % cond
logger.debug(statement)
self.cursor.execute(statement)
affected = self.cursor.rowcount
self.lock.release()
return affected
def get_applicant_sources(account_id: int):
response = requests.get(
url=base_url + '/account/{account_id}/applicant/sources'.format(
account_id=account_id),
headers=default_headers)
logger.debug(json.loads(response.text))
if response.status_code == 200:
return response
else:
raise Exception(response)
def Select(self, columns, table, cond=None):
self.lock.acquire()
statement = 'SELECT %s FROM %s' % (', '.join(columns), table)
if cond:
statement += ' WHERE %s' % cond
logger.debug(statement)
self.cursor.execute(statement)
results = self.cursor.fetchall()
self.lock.release()
return results
def Delete(self, table, cond=None):
self.lock.acquire()
statement = 'DELETE FROM %s' % table
if cond:
statement += ' WHERE %s' % cond
logger.debug(statement)
self.cursor.execute(statement)
affected = self.cursor.rowcount
self.lock.release()
return affected
def run(self):
# get the payload
payload = self.request.get_json()
# get user_id
user_id = payload["wm.euId"]
# convert user_id to email
user_email = lookup_user_by_id(env, user_id)
if len(user_email) <= 0:
logger.info(
f"User email not found, most likely system was accessed without auth"
)
user_email = "None"
else:
logger.info(f"User email: {user_email}")
# remove tabs and spaces from e-mail before adding to payload
payload["user_email"] = user_email.replace(" ",
"").replace("\t",
"").lower()
logger.debug(f"Payload with user_email: {payload}")
# change any keys with a . to a _ because mongo doesn't like .
updated_payload = {}
for k, v in payload.items():
updated_payload[k.replace(".", "_")] = payload[k]
logger.debug(f"Updated payload: {updated_payload}")
# default to tasks table
collection = db[tasks_tbl]
# if it's a task, store it in task collection
# with proper names
if self.kind == "task":
collection = db[tasks_tbl]
# if it's a SWT started event, store it in the started collection
elif self.kind == "started":
collection = db[started_tbl]
# if it's a SWT started event, store it in the started collection
elif self.kind == "survey":
collection = db[survey_tbl]
insert = collection.insert_one(updated_payload)
logger.info(insert.inserted_id)
logger.info("Successfully inserted data into DB")
def __load(self, label):
"""Get output of coresponding command or if __data_dir is set load
content of coresponding file and store it to self.__data[label].
If command fails, usually "['']" is stored."""
assert label not in self.__data
# Are we running on live system or from directory?
if self.__data_dir == None:
if label not in self.__access_list:
self.__access_list[label] = self.config['commands'][label]
# TODO: Add some timeouts, ulimit, nice... (?)
logger.debug("Going to execute '%s' for '%s'" %
(self.config['commands'][label], label))
# FIXME: is it OK to have shell=True here from secuity stand-point?
process = subprocess.Popen([self.config['commands'][label]],
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# FIXME: is this correct way to run this? Can not we got stuck when the data are too big?
stdout, stderr = process.communicate()
if len(stderr) != 0:
logger.warn("Command '%s' failed with '%s'" %
(self.config['commands'][label], stderr))
raise DataNotAvailable(
"Command '%s' failed with '%s'" %
(self.config['commands'][label], stderr))
self.__data[label] = stdout.strip().split("\n")
else:
our_file = None
our_file_rel = None
for relative_file in self.config['files'][label]:
f = os.path.join(self.__data_dir, relative_file)
if os.path.isfile(f):
our_file = f
our_file_rel = relative_file
break
if our_file:
logger.debug("Going to load '%s' for '%s'" % (f, label))
if label not in self.__access_list:
self.__access_list[label] = our_file_rel
try:
fp = open(f, 'r')
except IOError:
logger.warn("Failed to load %s for %s" % (f, label))
raise DataNotAvailable("Failed to load %s for %s" %
(f, label))
self.__data[label] = fp.read().splitlines()
fp.close()
else:
logger.warn("Suitable file for %s not found" % label)
raise DataNotAvailable("Suitable file for %s not found" %
label)
def commit_condition_data(self):
fields = {
"air_quality_index": self.air_quality_index,
"condition": self.condition,
"dewpoint": self.dewpoint,
"humidity": self.humidity,
"pressure": self.pressure,
"temperature": self.temperature,
"visibility": self.visibility,
"wind_direction": self.wind_direction,
"wind_speed": self.wind_speed,
"wind_gust": self.wind_gust,
}
# tags = {"type":"temp"}
tags = {}
tags.update(self.extra_data.get("tags",{}))
# print(tags)
json_body = [
{
"measurement": "weather_data",
"tags": self.extra_data.get("tags",{}),
"time": time.asctime(self.updated_at),
"fields": fields
},
{
"measurement": "weather_data",
"tags": tags,
# "tags": {
# "region": "oshawa"
# },
"time": time.asctime(time.gmtime()),
"fields": fields
}
]
# print(json_body)
# tsdb.write_points(json_body, database='weather_data')
# result = tsdb.query('select value from weather_data;',database='weather_data')
# print("Result: {0}".format(result))
# now = datetime.datetime.now(tz=datetime.timezone.utc)
# hour = now.replace(minute=0,second=0,microsecond=0)
ss = (f"""delete from "weather_data" where region='{tags['region']}' and time > '{time.strftime('%Y-%m-%dT%H:%M:%SZ',self.updated_at)}' and time < '{time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime())}' """)
# ss = (f"""delete from "weather_data" where time > '{time.asctime(self.updated_at)}' and time < '{(str(hour))[:-6]}' """)
# print(ss,self.updated_at)
tsdb.query(ss)
# print(json_body)
tsdb.write_points(json_body, database='weather_data')
logger.debug(f'Region: "{tags["region"]:10}". temp: {self.temperature} C')
