def post(self):
response = ""
try:
# 参数是字典，不上传文件
if self.data_type == "data" and self.upload_file == "":
response = self.session.post(url=self.url, data=self.parameter)
# 参数是字典，上传文件
elif self.data_type == "data" and self.upload_file != "":
response = self.session.post(url=self.url,
data=self.parameter,
files=self.upload_file)
# 参数是json，上传文件
elif self.data_type == "json" and self.upload_file != "":
response = self.session.post(url=self.url,
json=self.parameter,
files=self.upload_file)
# 参数是json，不上传文件
elif self.data_type == "json" and self.upload_file == "":
response = self.session.post(url=self.url, json=self.parameter)
log.debug("运行post请求成功，请求的参数是：{}".format(self.parameter))
log.info("运行post请求成功")
except Exception as e:
log.error("post请求失败！，错误信息是：{}".format(e))
log.error("post请求失败！，请求的参数是：{}".format(self.parameter))
raise e
return response.json()
def handle(self, *args, **options):
log.info('Syncing missing metadata...')
sources = Source.objects.filter(
Q(copy_thumbnails=True) | Q(write_nfo=True))
for source in sources.order_by('name'):
log.info(f'Finding media for source: {source}')
for item in Media.objects.filter(source=source, downloaded=True):
log.info(
f'Checking media for missing metadata: {source} / {item}')
thumbpath = item.thumbpath
if not thumbpath.is_file():
if item.thumb:
log.info(
f'Copying missing thumbnail from: {item.thumb.path} '
f'to: {thumbpath}')
copyfile(item.thumb.path, thumbpath)
else:
log.error(
f'Tried to copy missing thumbnail for {item} but '
f'the thumbnail has not been downloaded')
nfopath = item.nfopath
if not nfopath.is_file():
log.info(f'Writing missing NFO file: {nfopath}')
write_text_file(nfopath, item.nfoxml)
log.info('Done')
def addBorrow(indexList):
try:
memcache_client_thread = MemcacheClient(('localhost', 11211))
for index in indexList:
try:
(obj_id, owner, borrower, price, lent, release_time,
class_id, exp, create_index,
bp) = trade_contract.call().getBorrowingItem(index)
egg_no = getMonsterEgg(memcache_client_thread, obj_id)
borrowList[index] = {
'index': index,
'monster_id': obj_id,
'class_id': class_id,
'exp': exp,
'bp': bp,
'owner': owner,
'borrower': borrower,
'lent': lent,
'release_time': release_time,
'create_index': create_index,
'lending_price': price,
'bonus_egg': egg_no
}
except BadFunctionCallOutput as e:
log.error(
'cron_borrow_failed|index=%s, error=%s,traceback=%s',
index, e, traceback.format_exc())
# print "done: ", index
except Exception as e:
log.error('cron_borrow|error=%s,traceback=%s', e,
traceback.format_exc())
def verify(self):
assert_data = self.assert_data.split(" ")
expect = ""
if assert_data[2].isdigit():
expect = int(assert_data[2])
else:
expect = assert_data[2]
try:
if assert_data[1] == "==":
assert eval(assert_data[0]) == expect
elif assert_data[1] == "<":
assert eval(assert_data[0]) < expect
elif assert_data[1] == ">":
assert eval(assert_data[0]) > expect
elif assert_data[1] == "in":
assert expect in eval(assert_data[0])
elif assert_data[1] == "!=":
assert eval(assert_data[0]) != expect
log.info("检查点校验成功")
except Exception as e:
log.error("检查点检验失败！预期结果是：{}，实际结果是：{}".format(
self.assert_data, assert_data[0] + " " + assert_data[1] + " " +
eval(assert_data[0])))
raise e
def wait_element_clickable(self, loc, img_info, timeout=15, poll_frequency=0.5):
"""
等待元素可点击
:param loc:定位元素表达式
:param img_info:发生错误时截图文件名
:param timeout:等待超时时间
:param poll_frequency:查询频率
:return:超时错误或者元素
"""
# 获取当前时间
start_time = time()
try:
ele = WebDriverWait(self.driver, timeout, poll_frequency).until(EC.element_to_be_clickable(loc))
except Exception as e:
# 输出错误日志
log.error("元素{}等待可点击超时".format(loc))
log.exception(e)
# 对当前错误页面截图
self.screen_shot(img_info)
raise e
else:
# 打印等待时间，返回元素
end_time = time()
log.info('元素{}可点击，等待时间{}秒'.format(loc, start_time - end_time))
return ele
def update_teacher_score(teacher_id, score):
t = Teacher.objects.filter(id=teacher_id).first()
if not t:
log.error("update_teacher_score_teacher_not_found|teacher_id",
teacher_id)
return False
review_count = t.review_count
rate = review_count / (review_count + 1)
t.recommend_score = t.recommend_score * rate + score["recommend_score"] / (
review_count + 1)
t.content_score = t.content_score * rate + score["content_score"] / (
review_count + 1)
t.work_score = t.work_score * rate + score["work_score"] / (review_count +
1)
t.exam_score = t.exam_score * rate + score["exam_score"] / (review_count +
1)
t.review_count = review_count + 1
try:
t.save()
return True
except Exception as e:
log.error(
"update_teacher_score_exception|teacher_id={},exception={}".format(
teacher_id, e))
return False
def fix_stats_monster():
infura_client = InfuraClient(INFURA_API_URL)
data_contract = infura_client.getDataContract()
monster_records = EtheremonDB.EmaMonsterDataTab.objects.filter(
Q(b0=0) | Q(b1=0) | Q(b2=0) | Q(b3=0) | Q(b4=0) | Q(b5=0)).all()
for monster in monster_records:
if monster.monster_id < 32599:
continue
base_stats = []
for index in xrange(0, 6):
stat_value = data_contract.call().getElementInArrayType(
DataArrayType.STAT_BASE, monster.monster_id, index)
base_stats.append(stat_value)
if 0 in base_stats:
log.error("fix_monster_invalid_stat|monster_id=%s,base_stats=%s",
monster.monster_id, base_stats)
continue
monster.b0 = base_stats[0]
monster.b1 = base_stats[1]
monster.b2 = base_stats[2]
monster.b3 = base_stats[3]
monster.b4 = base_stats[4]
monster.b5 = base_stats[5]
monster.exp = 0
monster.save()
_sync_monster_id(data_contract, monster.monster_id)
time.sleep(0.05)
log.info("fix_monster_stats|monster_id=%s", monster.monster_id)
def hook(event):
filename = os.path.basename(event['filename'])
if event['status'] == 'error':
log.error(f'[youtube-dl] error occured downloading: {filename}')
elif event['status'] == 'downloading':
downloaded_bytes = event.get('downloaded_bytes', 0)
total_bytes = event.get('total_bytes', 0)
eta = event.get('_eta_str', '?').strip()
percent_done = event.get('_percent_str', '?').strip()
speed = event.get('_speed_str', '?').strip()
total = event.get('_total_bytes_str', '?').strip()
if downloaded_bytes > 0 and total_bytes > 0:
p = round((event['downloaded_bytes'] / event['total_bytes']) * 100)
if (p % 5 == 0) and p > hook.download_progress:
hook.download_progress = p
log.info(f'[youtube-dl] downloading: {filename} - {percent_done} '
f'of {total} at {speed}, {eta} remaining')
else:
# No progress to monitor, just spam every 10 download messages instead
hook.download_progress += 1
if hook.download_progress % 10 == 0:
log.info(f'[youtube-dl] downloading: {filename} - {percent_done} '
f'of {total} at {speed}, {eta} remaining')
elif event['status'] == 'finished':
total_size_str = event.get('_total_bytes_str', '?').strip()
elapsed_str = event.get('_elapsed_str', '?').strip()
log.info(f'[youtube-dl] finished downloading: {filename} - '
f'{total_size_str} in {elapsed_str}')
else:
log.warn(f'[youtube-dl] unknown event: {str(event)}')
def execute(query):
try:
log.info("Execute query: %s" % (str(query)))
return DBConnection.connection().execute(query)
except Exception, exc:
log.error("db.execute: %(error)s" % {'error': exc.message})
return None
def main():
while True:
try:
update_battle()
except Exception as e:
log.error('cron_battle_error|error=%s,traceback=%s', e, traceback.format_exc())
time.sleep(5)
def test_new_supercargo(self, init):
"""新增一个押运员"""
self.driver = init
try:
log.info("-----> 开始新增押运员")
self.driver.find_element(By.ID, allData.get_element_info(0)).click()
self.driver.find_element(By.ID, allData.get_element_info(1)).click()
self.driver.find_elements(By.ID, allData.get_element_info(2))[1].click()
self.driver.find_element(By.ID, allData.get_element_info(3)).click()
self.driver.find_element(By.ID, allData.get_element_info(4)).send_keys(new_supercargo)
self.driver.find_element(By.ID, allData.get_element_info(5)).send_keys(new_supercargo_num)
self.driver.find_element(By.ID, allData.get_element_info(6)).click()
self.driver.find_element(By.XPATH, reuseData.get_element_info(0)).click()
self.driver.find_element(By.ID, reuseData.get_element_info(1)).click()
self.driver.find_elements(By.ID, reuseData.get_element_info(2))[0].click()
time.sleep(1)
pageView.adb_tap((110, 260))
time.sleep(1)
pageView.adb_tap((668, 46))
self.driver.find_element(By.ID, reuseData.get_element_info(3)).click()
self.driver.find_element(By.ID, reuseData.get_element_info(4)).click()
self.driver.find_element(By.ID, reuseData.get_element_info(5)).click()
self.driver.find_element(By.ID, reuseData.get_element_info(7)).click()
time.sleep(3)
except Exception as e:
log.error("异常情况，返回错误信息是->: {0}".format(e))
screen_shot(self.driver, allData.get_id() + '.png')
def update_course_score(course_id, score):
course = Course.objects.filter(id=course_id).first()
if not course:
log.error("update_course_score_course_not_found|course_id=", course_id)
return False
review_count = course.review_count
rate = review_count / (review_count + 1)
course.recommend_score = course.recommend_score * rate + score[
"recommend_score"] / (review_count + 1)
course.content_score = course.content_score * rate + score[
"content_score"] / (review_count + 1)
course.work_score = course.work_score * rate + score["work_score"] / (
review_count + 1)
course.exam_score = course.exam_score * rate + score["exam_score"] / (
review_count + 1)
course.review_count = review_count + 1
course.last_review = TimeUtils.now_ts()
try:
course.save()
return True
except Exception as e:
log.error(
"update_course_score_exception|course_id={},exception={}".format(
course_id, e))
return False
def user_logout(driver):
try:
driver.find_element(By.ID, allData.get_element_info(3)).click()
driver.find_element(By.ID, allData.get_element_info(4)).click()
driver.find_element(By.ID, allData.get_element_info(5)).click()
driver.find_element(By.ID, allData.get_element_info(6)).click()
except NoSuchElementException:
log.error("异常退出，未找到主页面“我的”元素！")
def task_task_failed(sender, task_id, completed_task, **kwargs):
# Triggered after a task fails by reaching its max retry attempts
obj, url = map_task_to_instance(completed_task)
if isinstance(obj, Source):
log.error(
f'Permanent failure for source: {obj} task: {completed_task}')
obj.has_failed = True
obj.save()
def calibrateCameraAndLidar():
res = {"code": "99", "msg": "", "result": {}}
data2d = []
data3d = []
xyz = (0, 0, 0)
try:
data = json.loads(request.get_data(as_text=True))
token = data['token']
prjId = data['prjId']
raw3d = data['coordinateData0']
raw2d = data['coordinateData1']
xyz = (float(data['BLH']["x"]), float(data['BLH']["y"]),
float(data['BLH']["z"]))
mtx = np.array(data["para"]["mtx"])
dist = np.array(data["para"]["dist"])
assert (len(raw2d) == len(raw3d)), "接收坐标对数据长度不一致"
assert (len(raw2d) >= 6), "接收坐标对数据长度小于6"
for i in range(0, len(raw2d)):
tmpraw2dU = float(raw2d[i]["axisX"])
tmpraw2dV = float(raw2d[i]["axisY"])
tmpraw3dX = float(raw3d[i]["axisX"])
tmpraw3dY = float(raw3d[i]["axisY"])
tmpraw3dZ = float(raw3d[i]["axisZ"])
data2d.append((tmpraw2dU, tmpraw2dV))
data3d.append((tmpraw3dX, tmpraw3dY, tmpraw3dZ))
log.info("Successful transfer of points")
except Exception as e:
log.error(e)
res['msg'] = 'The server receives a bad json'
return get_result_response(EasyDict(res))
log.info("ip:{}".format(request.remote_addr))
rotM, tvec, rvec, Cx, Cy, Cz, thetaX, thetaY, thetaZ = calibrate_camera_and_lidar(
xyz, data2d, data3d, mtx, dist)
result = {
"rotM": list(map(np.ndarray.tolist, rotM)),
"tvec": list(map(np.ndarray.tolist, tvec)),
"rvec": list(map(np.ndarray.tolist, rvec)),
"Cx": Cx.tolist()[0],
"Cy": Cy.tolist()[0],
"Cz": Cz.tolist()[0],
"thetaX": thetaX,
"thetaY": thetaY,
"thetaZ": thetaZ
}
res["result"] = result
res["code"] = "00"
res["msg"] = "Success"
return get_result_response(EasyDict(res))
def init_args_parser():
parser = argparse.ArgumentParser()
parser.add_argument("--env", help="set environment for app")
args = parser.parse_args()
if args.env is None:
log.error("Error: Please enter your ENV")
sys.exit(1)
return args
def get(self):
response = ""
try:
response = self.session.get(url=self.url, params=self.parameter)
log.info("运行get请求成功")
except Exception as e:
log.error("get请求失败！，错误信息是：{}".format(e))
log.error("get请求失败！，请求参数是：{}".format(self.parameter))
return response.json()
def print_proxy_table(self):
"""随机打印一个代理IP的信息"""
p = ProxyTable()
try:
log.info('随机打印一个代理IP的信息')
member = p.fetch_proxy()
except Exception as e:
log.error(e)
else:
member.print_infos()
def user_login(driver):
try:
driver.find_element(By.ID, allData.get_element_info(0)).clear()
driver.find_element(By.ID, allData.get_element_info(0)).send_keys(
testData[5]['data']['username'])
driver.find_element(By.ID, allData.get_element_info(1)).send_keys(
testData[5]['data']['password'])
driver.find_element(By.ID, allData.get_element_info(2)).click()
except NoSuchElementException:
log.error("异常登录，未找到登录页面元素！")
def get(cache_name, cache_renew):
json_cache = '%s/%s.json' % (cache_path, cache_name)
try:
return json.load(open(json_cache, 'r'))
except (IOError, ValueError) as e:
log.error("Unpacking 'value_types.json' raise exception:\n %s" % str(e))
value_names = cache_renew()
json.dump(value_names, open(json_cache, 'w'))
return value_names
def main():
while True:
try:
start = time.time()
update_monster()
if DEBUG: print "Elapsed: ", time.time() - start
except Exception as e:
if DEBUG: traceback.print_exc()
log.error('cron_monster_error|error=%s,traceback=%s', e,
traceback.format_exc())
time.sleep(5)
def getSaveData(self, replaceKey=None):
'''
获取公共数据池中的数据
:param replaceKey:
:return:
'''
try:
return self.saveDatas[replaceKey]
except Exception:
log.error("格式化参数失败，公共参数中找不到{0}".format(replaceKey))
return ''
def update_battle():
castle_class = web3.eth.contract(abi=CASTLE_ABI)
castle_contract = castle_class(CASTLE_ADDRESS)
total_battle = castle_contract.call().totalBattle()
# print "total_battle: ", total_battle
log.info('update_battle|total_battle=%s', total_battle)
battle_id = 1
with open('cron_battle.log', 'r') as f:
battle_id = int(f.read())
# print "battle id start:", battle_id
log.info('update_battle|battle_id_start=%s', battle_id)
while battle_id <= total_battle:
(castle_id, attacker_address, result,
random_0, random_1, random_2,
castle_monster_exp_1, castle_monster_exp_2, castle_monster_exp_3) = castle_contract.call().getBattleDataLog(battle_id)
(attacker_monster_id_1, attacker_monster_id_2, attacker_monster_id_3,
attacker_supporter_id_1, attacker_supporter_id_2, attacker_supporter_id_3,
attacker_monster_exp_1, attacker_monster_exp_2, attacker_monster_exp_3) = castle_contract.call().getBattleAttackerLog(battle_id)
if not castle_id or not attacker_monster_id_1:
log.error('update_battle_error|battle_id=%s', battle_id)
break
# print "battle id update: ", battle_id
log.info('update_battle|battle_id=%s', battle_id)
try:
EtheremonDB.BattleLogTab.objects.create(
battle_id=battle_id,
castle_id=castle_id,
attacker_address=attacker_address,
attacker_monster_id_1=attacker_monster_id_1,
attacker_monster_id_2=attacker_monster_id_2,
attacker_monster_id_3=attacker_monster_id_3,
attacker_supporter_id_1=attacker_supporter_id_1,
attacker_supporter_id_2=attacker_supporter_id_2,
attacker_supporter_id_3=attacker_supporter_id_3,
result=result,
extra_data=json.dumps({
'castle_monster_exp_1': castle_monster_exp_1,
'castle_monster_exp_2': castle_monster_exp_2,
'castle_monster_exp_3': castle_monster_exp_3,
'attacker_monster_exp_1': attacker_monster_exp_1,
'attacker_monster_exp_2': attacker_monster_exp_2,
'attacker_monster_exp_3': attacker_monster_exp_3,
})
)
except IntegrityError:
log.warn('update_battle|re_update_id=%s', battle_id)
battle_id += 1
with open('cron_battle.log', 'w') as f:
f.write(str(battle_id))
def download_media_metadata(media_id):
'''
Downloads the metadata for a media item.
'''
try:
media = Media.objects.get(pk=media_id)
except Media.DoesNotExist:
# Task triggered but the media no longer exists, do nothing
log.error(f'Task download_media_metadata(pk={media_id}) called but no '
f'media exists with ID: {media_id}')
return
source = media.source
metadata = media.index_metadata()
media.metadata = json.dumps(metadata, default=json_serial)
upload_date = media.upload_date
# Media must have a valid upload date
if upload_date:
media.published = timezone.make_aware(upload_date)
else:
log.error(f'Media has no upload date, skipping: {source} / {media}')
media.skip = True
# If the source has a download cap date check the upload date is allowed
max_cap_age = source.download_cap_date
if media.published and max_cap_age:
if media.published < max_cap_age:
# Media was published after the cap date, skip it
log.warn(f'Media: {source} / {media} is older than cap age '
f'{max_cap_age}, skipping')
media.skip = True
# If the source has a cut-off check the upload date is within the allowed delta
if source.delete_old_media and source.days_to_keep > 0:
if not isinstance(media.published, datetime):
# Media has no known published date or incomplete metadata
log.warn(
f'Media: {source} / {media} has no published date, skipping')
media.skip = True
else:
delta = timezone.now() - timedelta(days=source.days_to_keep)
if media.published < delta:
# Media was published after the cutoff date, skip it
log.warn(f'Media: {source} / {media} is older than '
f'{source.days_to_keep} days, skipping')
media.skip = True
# Check we can download the media item
if not media.skip:
if media.get_format_str():
media.can_download = True
else:
media.can_download = False
# Save the media
media.save()
log.info(f'Saved {len(media.metadata)} bytes of metadata for: '
f'{source} / {media_id}')
def mk_dir(path):
is_exists = os.path.exists(path)
if not is_exists:
try:
os.makedirs(path)
except Exception as e:
log.error("%s目录创建失败：%s" % (str(path), e))
now = time.strftime("%Y-%m-%d %H_%M_%S")
os.mkdir(path + "\\" + str(now))
def __init__(self):
log.info('start connecting MySQL...')
try:
self.conf = ReadConfig()
self.host = self.conf.get('mysql', 'host')
self.port = int(self.conf.get('mysql', 'port'))
self.username = self.conf.get('mysql', 'username')
self.password = self.conf.get('mysql', 'password')
self.db_sys = self.conf.get('mysql', 'db_sys')
self.db_sf_full = self.conf.get('mysql', 'db_sf_full')
except Exception as e:
log.error('连接数据库失败\n错误信息如下\n'.format(e))
else:
log.info('连接数据库成功')
def click_element(self, loc, img_info):
"""
click封装
:param loc:
:param img_info:
:return:
"""
try:
self.driver.find_element(*loc).click()
except Exception as e:
log.error("元素{}点击失败".format(loc))
log.exception(e)
self.screen_shot(img_info)
raise e
else:
log.info("元素{}点击成功".format(loc))
def get_element(self, loc, img_info):
"""
封装find_element
:param loc:
:param img_info:
:return:
"""
try:
ele = self.driver.find_element(*loc)
except Exception as e:
log.error("定位{}元素失败".format(loc))
log.exception(e)
self.screen_shot(img_info)
else:
log.info("定位{}元素成功".format(loc))
return ele
def get_element_text(self, loc, img_info):
"""
获取元素文本信息
:param loc:定位器
:param img_info:错误截图信息
:return:text
"""
try:
text = self.driver.find_element(*loc).text
except Exception as e:
log.error("获取{}元素文本失败".format(loc))
log.exception(e)
self.screen_shot(img_info)
raise e
else:
log.info("获取{}元素文本成功".format(loc))
return text
def input_text(self, loc, text, img_info):
"""
文本输入
:param loc:
:param text:文本内容
:param img_info:
:return:
"""
try:
self.driver.find_element(*loc).send_keys(text)
except Exception as e:
log.error("文本{}输入失败".format(text))
log.exception(e)
self.screen_shot(img_info)
raise e
else:
log.info("文本{}输入成功".format(text))
def test_normal(self, case):
'''
:param case: 测试用例对象
:return:
'''
apiParam = testBase.buildRequestParam(case)
response = testBase.parseHttpRequest(case.url, case.method,
eval(apiParam))
responseData = response.json()
if response.status_code == 200:
super().saveResult(responseData, case.save) # 对返回结果进行提取保存。
# return super().verifyResult(responseData, case.verify) # 验证预期信息
verifyStr = case.verify
if (StringUtil().isEmpty(verifyStr)):
return
allVerify = self.getCommonParam(verifyStr)
log.info('验证数据：{0}'.format(allVerify))
pattern = re.compile("([^;]*)=([^;]*)")
it = pattern.finditer(allVerify)
for matcher in it:
actualValue = self.getBuildValue(responseData,
matcher.group(1))
exceptValue = self.getBuildValue(responseData,
matcher.group(2))
log.info('验证转换后的值:{0}=?{1} '.format(str(actualValue),
str(exceptValue)))
try:
self.assertEqual(str(actualValue), str(exceptValue))
# AssertUtil().contains(str(actualValue), str(exceptValue))
except AssertionError as e:
# print('测试用例执行]不通过')
resul = '失败'
log.error(e)
raise e
else:
resul = '通过'
# print('测试用例执行通过')
finally:
log.info('用例id为:{}，用例标题为:{}，结果是:{}'.format(
case.case_row_id - 1, case.desc, resul))
r.write(case.case_row_id, 8, resul)
def index_source_task(source_id):
'''
Indexes media available from a Source object.
'''
try:
source = Source.objects.get(pk=source_id)
except Source.DoesNotExist:
# Task triggered but the Source has been deleted, delete the task
delete_index_source_task(source_id)
return
# Reset any errors
source.has_failed = False
source.save()
# Index the source
videos = source.index_media()
if not videos:
raise NoMediaException(
f'Source "{source}" (ID: {source_id}) returned no '
f'media to index, is the source key valid? Check the '
f'source configuration is correct and that the source '
f'is reachable')
# Got some media, update the last crawl timestamp
source.last_crawl = timezone.now()
source.save()
log.info(f'Found {len(videos)} media items for source: {source}')
for video in videos:
# Create or update each video as a Media object
key = video.get(source.key_field, None)
if not key:
# Video has no unique key (ID), it can't be indexed
continue
try:
media = Media.objects.get(key=key, source=source)
except Media.DoesNotExist:
media = Media(key=key)
media.source = source
try:
media.save()
log.info(f'Indexed media: {source} / {media}')
except IntegrityError as e:
log.error(f'Index media failed: {source} / {media} with "{e}"')
# Tack on a cleanup of old completed tasks
cleanup_completed_tasks()
# Tack on a cleanup of old media
cleanup_old_media()
