def __init__(self, loglevel):
'Create object that works out the jobs'
logger = Logger(loglevel) # configure logging
self.logger = logger.get() # get the logging function
self.storage = Storage(self.logger) # object for file system accesss
self.chrome = Chrome(
self.logger) # object to work with chrome/chromium
self.modulenames = [i['name'] for i in self.MODULES]
self.logins = dict()
self.options = dict()
for i in self.MODULES:
if i['login'] != None:
self.logins[i['name']] = {j: '' for j in i['login']}
else:
self.logins[i['name']] = None
if i['options'] != None:
self.options[i['name']] = {
j: i['options'][j]
for j in i['options']
}
else:
self.options[i['name']] = None
self.options_defaults = {
i: {j: self.options[i][j]['default']
for j in self.options[i]}
for i in self.options
}
def __init__(self,
username=None,
password=None,
headers=None,
user_type=None,
grant_type=None):
if not username: username = config.get_data_username
if not password: password = config.get_data_password
if not user_type: user_type = 1
if not grant_type: grant_type = password
if headers is None:
self.headers = {"Content-Type": "application/json;charset=UTF-8"}
self.username = username
self.session = requests.session()
self.log = Logger()
if len(password) == 32:
self.password = password
else:
self.password = "******"
self._config = self.base_yaml_info(curr_file=__file__,
module_key="dataUser")
self._get_header()
def on_match_act(self, act, room_id, user_id, score):
table = TableMgr().room_dict.get(room_id)
if table and table.match > 0:
player = table.player_dict.get(user_id)
if not player:
player = table.lookon_player_dict.get(user_id)
if player:
# 同步分数
player.match_score = score
msg_dict = {
"player": user_id,
"score": player.get_total_score()
}
table.send_table_msg(SYNC_SCORE, msg_dict)
# 处理动作
if act == "ready":
if player.state == "InitState" or player.state == "SettleState" or player.state == "PauseState":
if player.get_total_score(
) < player.table.conf.get_sit_score():
player.send(SCORE_LEAK, {})
else:
player.ready()
elif act == "enter":
pass
else:
Logger().warn("match room {0} ready user {1} not exist".format(
room_id, user_id))
def __init__(self, database_config):
self.cnx = None
self.cursor = None
self.db_is_connected = False
self.username = database_config[Config.Keys.Database.username]
self.password = database_config[Config.Keys.Database.password]
self.host = database_config[Config.Keys.Database.host]
self.logger = Logger(LoggerConfig.file_path)
def test_back_login(self, user, pwd, expect):
self.PageBackLogin.back_login(user, pwd)
ret = self.driver.current_url
try:
assert expect in ret
print('断言通过，测试后台登录通过')
except AssertionError:
self.PageBackLogin.base_get_image()
Logger().get_logger('login.log').error('断言失败，测试后台登录不通过')
raise
def test_check_article(self, title, channel):
self.PageCheckArticle.check_article(title, channel)
ret = self.PageCheckArticle.find_article()
try:
assert ret
print('断言成功，测试审核文章通过')
except AssertionError:
self.PageCheckArticle.base_get_image()
Logger().get_logger('login.log').error('断言失败，测试审核文章不通过')
raise
def on_body(self, data):
try:
msg_dict = msgpack.unpackb(data)
except Exception, e:
print e, self.address
self.close()
from base.logger import Logger
Logger().local(
"fake_ip.log",
self.address[0] + ":" + str(self.address[1]) + ":unpack")
return
def _train_auto_encoders():
n_folds = 1
top = None
val_top = None
train_bsize = 256
test_b_size = 64
num_planes = 2
scores = []
one_transform = transforms.Compose([
Flip(axis=2, targets_also=True, rnd=True),
Flip(axis=1, targets_also=True, rnd=True),
Rotate(90, targets_also=True, rnd=True),
Rotate(180, targets_also=True, rnd=True),
Ravel(),
ToTensor()
])
val_transform = transforms.Compose([Ravel(), ToTensor()])
for f in range(n_folds):
main_logger = Logger("../logs/enc/", erase_folder_content=False)
train_set = AutoEncoderDataset("../data/all.npy",
transform=one_transform,
top=top)
train_loader = DataLoader(train_set,
batch_size=train_bsize,
num_workers=12,
pin_memory=True,
shuffle=True)
val_set = AutoEncoderDataset("../data/folds/test_1.npy",
transform=val_transform,
top=val_top)
val_loader = DataLoader(val_set,
batch_size=test_b_size,
num_workers=6,
pin_memory=True)
encoder = VariationalAutoEncoder(num_planes, fold_number=None)
if torch.cuda.is_available():
encoder.cuda()
optim = torch.optim.Adam(encoder.parameters(),
lr=0.001,
weight_decay=0)
best = encoder.fit(optim,
loss_function,
train_loader,
val_loader,
100,
logger=main_logger)
scores.append(best)
print()
print("Best was ", best)
print(scores)
return scores
def __init__(self, deviceCode, socket_addr, aes_key):
self.deviceCode = deviceCode
self.socket_addr = socket_addr
self.aes_key = aes_key
self.log = Logger()
self.simulate_socket_conn()
self.simulate_device_login()
g1 = gevent.spawn(self.simulate_device_beat)
g1.join()
def on_head(self, data):
self.last_time = time.time()
self.head_data = data
size = ord(data[0]) * 256 + ord(data[1])
if size <= 0 or size > 4096:
print "bad package, size:", size, " ", self.address
self.close()
from base.logger import Logger
Logger().local(
"fake_ip.log",
self.address[0] + ":" + str(self.address[1]) + ":size")
return
self._stream.read_bytes(size, self.on_body)
def test_article(self, name, content, expect):
self.PageArticle.option_content()
sleep(2)
self.PageArticle.article(name, content)
ret = self.PageArticle.get_info()
sleep(2)
try:
assert ret == expect
print('实际结果为{}，预期结果为{},测试发布文章通过'.format(ret, expect))
except AssertionError:
print('实际结果为{}，预期结果为{},测试没有通过'.format(ret, expect))
self.PageArticle.base_get_image()
Logger().get_logger('login.log').error('断言失败，测试发布文章没有通过')
raise
def __init__(self, room_id, room_uuid, group_id, guild_id, match, owner,
kwargs):
super(Table, self).__init__()
self.chairs = 6 # 默认人数
self.room_id = room_id #桌子ID
self.room_uuid = room_uuid
self.owner = owner #房主ID
self.group_id = group_id # 群id
self.guild_id = guild_id # 公会ID
self.guild_admins = [] #公会管理员Id
self.match = match # 比赛房
self.owner_info = None
self.kwargs = str(kwargs)
self.player_dict = {}
self.seat_dict = {} #桌子上的玩家对象
self.lookon_player_dict = {} # 旁观玩家列表
self.machine = None
self.state = None
self.dismiss_state = False
self.dismiss_sponsor = None
self.dismiss_time = 0
self.logger = Logger() # 战斗日志
self.dealer_seat = -1 # 庄家位置
self.active_seat = -1
self.active_card = 0
self.discard_seat = -1
self.event = None
self.cards_total = 136
self.base_score = 0 # 庄家压分 诈金牛奖金池
self.conf = None # 桌子配置
self.sport_id = 0
self.st = time.time()
self.dt = self.st + 20 * 60
#20分钟后解散房间
if match > 0:
self.dt = self.st + 72 * 3600
self.et = 0
self.replay = [] # 桌子记录
self.cards_on_desk = [] # 当前桌子牌堆
self.cur_round = 1 # 当前回合数
self.timers = {}
self.timer_active = True
self.show_card_end_time = 0
# 洗牌使用
self.niu_max = 0 # 大牌型出现次数
Machine(self)
def __init__(self, session=False, verbose=False):
# 解决控制台输出 InsecureRequestWarning 的问题
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
self.log = Logger()
self.headers = {}
self.verbose = verbose
self.info = dict()
if session:
self.request = requests.session()
else:
self.request = requests
def __init__(self, username=None, password=None, headers=None):
if not username: username = config.get_b2b_username
if not password: password = config.get_b2b_password
if headers is None:
self.headers = {"Content-Type": "application/json;charset=UTF-8"}
self.username = username
self.session = requests.session()
self.log = Logger()
if len(password) == 32:
self.password = password
else:
self.password = "******"
self._config = self.base_yaml_info(curr_file=__file__,
module_key="b2bUser")
self._get_header()
def train():
from cnn.simple_ds import SimpleIcebergDataset
from cnn.dataset import IcebergDataset, Ravel, ToTensor
from torch.utils.data import DataLoader
import torch
from base.logger import Logger
main_logger = Logger("../logs/simple", erase_folder_content=True)
ds = SimpleIcebergDataset("../data/for_train_encoder.npy", transform=ToTensor())
val_ds = SimpleIcebergDataset("../data/for_test_encoder.npy", transform=ToTensor())
ldr = DataLoader(ds, batch_size=64)
val_ldr = DataLoader(val_ds, batch_size=64)
model = SimpleMLP()
optim = torch.optim.Adam(model.parameters(), lr=0.0001, weight_decay=0.005)
loss_fn = nn.BCELoss()
if torch.cuda.is_available():
model.cuda()
loss_fn.cuda()
best = model.fit(optim, loss_fn, ldr, val_ldr, 250, logger=main_logger)
print(best)
def handler(cmd, msg_dict, session):
if cmd == CG_CREATE_ROOM:
create_room(msg_dict, session)
elif cmd == CG_DISMISS_ROOM:
dismiss_room(msg_dict, session)
elif cmd == CG_SYNC_ROOM:
sync_room(msg_dict, session)
elif cmd == CG_USER_TOKEN:
user_token(msg_dict, session)
elif cmd == CG_MATCH_SCORE:
match_score(msg_dict, session)
elif cmd == GC_ROOM_RESET:
room_reseted(msg_dict, session)
elif cmd == CG_EMO_AMOUNT:
emo_amount(msg_dict, session)
elif cmd == GC_MATCH_ACT:
match_act(msg_dict, session)
elif cmd == CG_CREATE_SPORT_ROOM:
create_sport_room(msg_dict, session)
elif cmd == CG_DISMISS_SPORT:
dismiss_sport(msg_dict, session)
else:
Logger().warn("center client error cmd:%d"%cmd)
import pytest
from conftest import cases_path, max_fail
from base.logger import Logger
import os
logger = Logger('root').getlog()
if __name__ == '__main__':
pytest.main(["-s", "--alluredir", "./report/xml", "--maxfail", max_fail])
os.system('allure generate report/xml/ -o report/html --clean')
logger.info("test end! Generate test report")
def enter(self, room_id, player_id, info, user_token, session):
print "enter room %d" % room_id
table = self.room_dict.get(room_id)
if not table:
if room_id in self.room_settle_cache:
send(SETTLEMENT_FOR_ROOM_DN, self.room_settle_cache[room_id],
session)
msg_dict = dict()
msg_dict["code"] = 0
send(DISMISS_ROOM, msg_dict, session)
else:
# 给前端返回房间不存在的错误
msg_dict = dict()
msg_dict["code"] = 1
send(ENTER_ROOM, msg_dict, session)
print("room {0} not exist, player {1} enter failed".format(
room_id, player_id))
return
#检测token是否合法
token = redis.get("token:{0}".format(player_id))
if token == None or token != user_token:
msg_dict = dict()
msg_dict["code"] = 3 #token验证不通过，非法用户
send(ENTER_ROOM, msg_dict, session)
table.logger.info("token error: server;{0} client:{1}".format(
token, user_token))
return
if table.room_id != room_id:
self.room_dict[table.room_id] = table
del self.room_dict[room_id]
msg_dict = dict()
msg_dict["code"] = 1
send(ENTER_ROOM, msg_dict, session)
table.logger.fatal(
"room id map error: msg {0} actually {1}".format(
room_id, table.room_id))
return
from base.match_mgr import MatchMgr
player = table.player_dict.get(player_id)
if player:
# 服务重启后player没有session
if player.session:
if session != player.session:
player.table.logger.info(
"player {0} cancel old session {1}".format(
player_id, player.session.uuid))
# SessionMgr().cancel(player.session)
player.session.close()
SessionMgr().register(player, session)
player.table.logger.info(
"player {0} register new session {1}".format(
player_id, player.session.uuid))
if player.seat == -1:
seat = -1
for seat in range(table.chairs):
if seat in table.seat_dict.keys():
continue
break
player.seat = seat
MatchMgr().player_enter(player)
player.reconnect()
player.reload_extra()
player.online_status(True)
else:
player = table.lookon_player_dict.get(player_id)
if player and player.session and session != player.session:
player.table.logger.info(
"player {0} cancel old session {1}".format(
player_id, player.session.uuid))
player.session.close()
table.enter_room(player_id, info, session)
Logger().local("ip.log",
session.address[0] + ":" + str(session.address[1]))
def process_args(args, kwargs, options):
""" process arguments"""
# create the output directory
out_dir = args.output
if os.path.exists(out_dir) and not os.path.isdir(out_dir):
if not ((hasattr(args, 'realtime') and args.realtime)
or (hasattr(args, 'use_prefit_model') and args.use_prefit_model)):
dtime = datetime.fromtimestamp(os.path.getctime( out_dir)).strftime('%y%m%d_%H%M%S')
name = out_dir+'_'+ dtime
os.rename( out_dir, name)
if not os.path.exists(out_dir):
os.makedirs( out_dir)
# create logger
log_name = os.path.join(out_dir, args.task.title() + '.log')
args.logger = Logger(log_name)
args.date_format = __date_format__
# standard output the running of module with current Python version
args.logger.start("Running task '{task}', using '{prog} v{version}' under Python {py} by '{user}' on '{sys}', output to '{output}'".format(
task=args.task,
prog=os.path.split(kwargs['__current_module__'])[1],
version=kwargs['__version__'],
py='.'.join(map(str, __sys_version__[:3])),
user=__user__,
sys=__sys_name__,
output=args.output)
)
#args.logger.info("using arguments: {args}".format(args=args.__dict__))
if hasattr(args, 'force_cpu') and args.force_cpu:
# force tensoflow to use CPU only on machines with a GPU
os.environ["CUDA_VISIBLE_DEVICES"] = ""
# establish the input database connection if required
if hasattr(args, 'idb_connstr') and args.idb_connstr != '':
try:
# using sqlalchemy
#iengine = create_engine(conn_str=args.idb_connstr)
#args.idb = iengine.connect()
# using turbodbc
args.idb = DataBase(conn_str=args.idb_connstr)
except:
args.logger.critical("failed to connect to the input Database using the connection strings entered with '-d'.")
# establish the input database connection if required
if hasattr(args, 'odb_connstr') and args.odb_connstr != '':
try:
engine = create_engine(args.odb_connstr, convert_unicode=True)
args.odb = Session(engine)
try:
__, abbr, project_name, run_name, task = args.output.split(os.sep)
args.logger.info("storing run '%s' records in the database." % run_name)
product = args.odb.query(Product).filter_by(abbr=abbr).first()
if not product:
args.logger.error("product abbr '%s' is not valid." % abbr)
raise ValueError("product abbr '%s' is not valid." % abbr)
project = args.odb.query(Project).filter_by(name=project_name, product=product).first()
if not project:
args.logger.error("project name '%s' is not valid." % project_name)
raise ValueError("project name '%s' is not valid." % project_name)
user = args.odb.query(User).filter_by(login=args.user).first()
except:
args.logger.error("failed to parse the project properties from the '-o' argument; the run won't be recorded in the database.")
raise ValueError("failed to parse the project properties from the '-o' argument; the run won't be recorded in the database.")
args.logger.info("storing run '%s' records in the database." % run_name)
run = args.odb.query(Run).filter_by(name=run_name, project=project).first()
if run:
args.logger.warning("run '%s' already exists; replacing the run results.")
args.odb.delete(run)
args.odb.flush()
run = Run(name=run_name, project=project, project_id=project.id, task=task)
project.runs.append(run)
if user:
run.user = user
inputs = []
for k in args.__dict__:
if getattr(args, k) is None:
pass
elif k in ['idb', 'odb', 'idb_connstr', 'odb_connstr', 'logger', 'date_format', 'task', 'output']:
pass
elif getattr(args, k) != '':
inputs.append(Parameter(name=k, value=str(getattr(args, k))))
run.inputs = inputs
args.run = run
args.odb.add(run)
args.odb.flush()
except:
args.logger.critical("failed to connect to and store run records in the output Database.")
if not hasattr(args, 'show'):
setattr(args, 'show', False)
if not args.show:
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
# suppress warning and debug info
# process list-type options
for key, option in options.items():
if option['nargs'] == '+' and type(getattr(args, key)) != list:
setattr(args, key, [getattr(args, key)])
# check the range for 'Test-to-Train' ratio
if hasattr(args, 'test_ratio'):
frange = (0, 1)
if args.test_ratio < frange[0] or args.test_ratio > frange[1]:
args.logger.critical("'test_ratio' is not in range [{}, {}}]".format(frange))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright (c) 2019 Jared Recomendable.
Licensed under the GNU General Public License Version 3.
This program DOES NOT COME WITH ANY WARRANTY, EXPRESS OR IMPLIED.
"""
from base.utils import *
from base.logger import Logger
logger = Logger(LoggerConfig.file_path)
class QueryConstructor:
"""Class for constructing a query to be executed by the DBMS. Specifically made with the goal to automate adding
conditions using the WHERE clause in SQL
"""
def __init__(self, table_name: str, schema_name: str = ""):
"""Initialise the object. Optionally pass a schema name to the constructor.
:type table_name: str
:type schema_name: str
"""
self.table_name = table_name
self.schema_name = schema_name
self.field_list = []
self.value_list = []
self.condition = ""
self.order = ""
def reset(self):
def on_close(self):
self._is_connected = False
tornado.ioloop.IOLoop.instance().call_later(5, self.reconnect)
Logger().warn("center connect closed, reconnect 5s later")
class Connection(object):
uuid = None
last_time = 0
def __init__(self, stream, address):
from base.session_mgr import SessionMgr
self.uuid = str(uuid4())
SessionMgr().add(self)
self._stream = stream
self.address = address
self.last_time = time.time()
self._stream.set_close_callback(self.on_close)
self._stream.read_bytes(8, self.on_head)
self.head_data = None
print "connection opened.", address, "count:", len(
SessionMgr().session_set)
def on_head(self, data):
self.last_time = time.time()
self.head_data = data
size = ord(data[0]) * 256 + ord(data[1])
if size <= 0 or size > 4096:
print "bad package, size:", size, " ", self.address
self.close()
from base.logger import Logger
Logger().local(
"fake_ip.log",
self.address[0] + ":" + str(self.address[1]) + ":size")
return
self._stream.read_bytes(size, self.on_body)
def checkcrc(self, cmd, body_data):
size = ord(self.head_data[0]) * 256 + ord(self.head_data[1])
crc_data = ""
if size < 122:
crc_data = self.head_data[4:8] + chr(int(cmd / 256)) + chr(
cmd % 256) + body_data[0:size]
else:
crc_data = self.head_data[4:8] + chr(int(cmd / 256)) + chr(
cmd % 256) + body_data[0:122]
if get_crc(crc_data) != ord(self.head_data[2]) * 256 + ord(
self.head_data[3]):
return False
return True
def on_body(self, data):
try:
msg_dict = msgpack.unpackb(data)
except Exception, e:
print e, self.address
self.close()
from base.logger import Logger
Logger().local(
"fake_ip.log",
self.address[0] + ":" + str(self.address[1]) + ":unpack")
return
if isinstance(msg_dict, dict):
cmd = msg_dict.get("cmd")
if not self.checkcrc(cmd, data):
print "check crc fail", self.address
self.close()
from base.logger import Logger
Logger().local(
"fake_ip.log",
self.address[0] + ":" + str(self.address[1]) + ":crc")
return
if cmd is not None:
from protocol.deserialize import receive
receive(cmd, msg_dict, self)
else:
print "bad msg dict.", self.address
self.close()
return
try:
self._stream.read_bytes(8, self.on_head)
except StreamClosedError:
pass
from time import sleep
import page
from base.logger import Logger
from base.webbase import WebBase
logger = Logger().get_logger('login.log')
class PageLogin(WebBase):
def login_input(self, user):
self.base_input(page.login_input, user)
def pwd_input(self, pwd):
self.base_input(page.pwd_input, pwd)
def login_click(self):
self.base_click(page.login_btn)
def login(self, user, pwd):
logger.info('正在登录，用户名：{}，密码：{}'.format(user, pwd))
self.login_input(user)
self.pwd_input(pwd)
self.login_click()
sleep(3)
def get_image(self):
self.base_get_image()
def get_nickname(self):
return self.base_get_text(page.nickname)
from base.logger import Logger
import time
from selenium.webdriver.common.by import By
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.wait import WebDriverWait
from selenium.common.exceptions import *
from selenium.webdriver.support import expected_conditions as ec
from conftest import IMG_DIR
#logger实例
logger = Logger(logger="BasePage").getlog()
class BasePage(object):
def __init__(self, login):
"""
:param login:conftest.py的login
"""
self.driver = login
#后退操作
def back(self):
self.driver.back()
logger.info("Click back on current page.")
def forward(self):
self.driver.forward()
logger.info('Click forward on current page.')
def open(self, url):
from base.base import BasePage
from base.logger import Logger
logger = Logger(logger="HomePage").getlog()
class HomePage(BasePage):
# locators
_search_input = "kw"
_search_button = "su"
def __init__(self, driver):
super().__init__(driver)
self.driver = driver
def enter_search(self, content):
self.element_send_keys(self._search_input, content, "id")
def click_search_button(self):
self.element_click(self._search_button, "id")
def search(self, content):
self.enter_search(content)
self.click_search_button()
def __init__(self, log_file=None, name=""):
self.name = self.name + name
if log_file is None:
log_file = self.name
self.logger = Logger(log_file + ".log")
self.functions = []
