def configure_process():
app.config["STARTED"] = False
app.config["SUCCESS"] = False
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
app.config['GENERATIONS'] = form.generations.data
app.config['INDIVIDUALS'] = form.individuals.data
app.config['TRIANGLES'] = form.triangles.data
app.config['MUTATION_PERCENTAGE'] = form.mutation_rate.data
app.config["CROSSOVER_RATE"] = form.crossover_rate.data
app.config["TRIANGULATION_METHOD"] = form.triangulation_method.data
else:
if form.errors:
Logger().error(form.errors)
for item, message in form.errors.items():
flash(f'{item}: {message}')
return redirect(request.url)
if not request.method == "POST":
return render_template("public/configure_process.html", form=form)
if not validate_input_image():
return redirect(request.url)
if request.method == 'POST' and request.form['submit_button'] == 'submit':
et = set_evo_config()
global thread
Logger().info('Client connected')
if not thread.is_alive():
Logger().info("Starting Thread")
thread = socketio.start_background_task(run_evolution, et=et)
return my_redirect()
def preparar_random_forest(self, tweets, classificacoes):
# create training and testing vars
x_train, x_test, y_train, y_test = train_test_split(tweets,
classificacoes,
test_size=0.20)
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
self.classificador = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer(use_idf=True, smooth_idf=True)),
('clf',
RandomForestClassifier(n_estimators=800,
min_samples_split=5,
min_samples_leaf=1,
max_features='sqrt',
max_depth=90,
bootstrap=False))
])
self.classificador.fit(x_train, y_train)
mensagem_treino = '\nCLASSIFICADOR RF TREINADO EM ' + str(
len(x_train)) + ' EXEMPLOS\n'
Logger.ok(mensagem_treino)
accuracy = cross_val_score(self.classificador,
tweets,
classificacoes,
cv=10,
n_jobs=-1)
mensagem_acuracia_10_fold = "\nModelo RF - ACURÁCIA 10-fold: %0.4f" % (
accuracy.mean())
Logger.ok(mensagem_acuracia_10_fold)
def save_search_weights(self, debug=False):
self.g_weight = parameters.HLTRAJ_G_WEIGHT
self.h_weight = parameters.HLTRAJ_H_WEIGHT
if settings.STEPSEQ_VERBOSITY >= 3:
print("g weight:", Logger.pp_double(self.g_weight), ", h_weight:",
Logger.pp_double(self.h_weight))
def __init__(self, domain, port):
self.logger = Logger(__name__).return_logger()
self.domain = domain
self.port = port
self.flag = 0 # 连接后置为1
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def train(args, get_dataloader_func=get_pix2pix_maps_dataloader):
logger = Logger(save_path=args.save, json_name='img2map')
epoch_now = len(logger.get_data('G_loss'))
model_saver = ModelSaver(
save_path=args.save,
name_list=[
'G', 'D', 'E', 'G_optimizer', 'D_optimizer', 'E_optimizer',
'G_scheduler', 'D_scheduler', 'E_scheduler', 'DLV3P',
"DLV3P_global_optimizer", "DLV3P_backbone_optimizer",
"DLV3P_global_scheduler", "DLV3P_backbone_scheduler"
])
visualizer = Visualizer(
keys=['image', 'encode_feature', 'fake', 'label', 'instance'])
sw = SummaryWriter(args.tensorboard_path)
G = get_G(args)
D = get_D(args)
model_saver.load('G', G)
model_saver.load('D', D)
params_G = sum([param.nelement() for param in G.parameters()])
params_D = sum([param.nelement() for param in D.parameters()])
print(f"{params_G}, {params_D}")
print(f"{params_G}")
sys.exit(0) # 测完退出
class UIDatabase:
def __init__(self, user):
Session = sessionmaker(bind=engine)
# * Main vars
self.s = Session()
self.user = user
# * Launcher
self.logger = Logger()
def inject_user(self):
"""
Inject all user information when connected.
"""
# records = self.s.query(Users).filter_by(name=self.user.username).first()
if self.s.query(Users).filter_by(
name=self.user.username).first() != self.user.username:
print(f'{self.user.username} already in db')
else:
user = Users(discriminator=self.user.discriminator,
email=self.user.email,
name=self.user.username,
verified=self.user.verified)
self.s.add(user)
self.s.commit()
self.logger.log('success',
f'{self.user.username} as been added to DB.')
self.s.close()
class InvertedIndex:
def __init__(self):
self._db = IndexDatabase()
self._tokenizer = Tokenizer()
self.__logger = Logger().get_logger(__name__)
def calculate_relevance(self, request):
scores = defaultdict(float)
total_docs_count = self._db.get_constant('total_docs_count')
for target_word in request:
word_meta = self._db.get(target_word)
target_docs = word_meta.keys()
for doc in target_docs:
idf = math.log(total_docs_count / len(target_docs))
scores[doc] += word_meta[doc] * abs(idf) / len(request)
return scores
def search(self, request, result_size):
parsed_request = self._tokenizer.tokenize(request)
if not parsed_request:
self.__logger.error('Empty search request.')
return None
target_request = [
word for word in parsed_request
if word in self._db.get_words_list()
]
relevance = self.calculate_relevance(target_request)
return sorted(relevance.items(),
key=lambda item: item[1],
reverse=True)[:result_size]
async def insert_feedback(cls, data: Feedback):
logger = Logger(cls.__name__)
logger.info(
f'Creating feedback - id: {data.id}, reference: {data.reference}, name: {data.name}'
)
await Mongo.get().feedback.insert_one(cls.__to_document(data))
def print_util(item_name, res):
obj_str = Logger.styled_text(item_name, "bold")
if res == SystemRunnerResults.UNFILLED:
return obj_str + ":\tunfilled"
if res == SystemRunnerResults.NEVER_CALCULATED:
return obj_str + ":\tnot calculated"
if res == SystemRunnerResults.FAILED:
return obj_str + ":\t" + Logger.styled_text("Failed", "FAIL")
if res == SystemRunnerResults.LOADED_FROM_PICKLE:
return obj_str + ":\t" + Logger.styled_text(
"Loaded from pickle", "BLUE")
if type(res) is list:
if res[0] == SystemRunnerResults.UNFILLED:
return obj_str + ":\tunfilled"
if res[0] == SystemRunnerResults.NEVER_CALCULATED:
return obj_str + ":\tnot calculated"
if res[0] == SystemRunnerResults.FAILED:
return obj_str + ":\t" + Logger.styled_text("Failed", "FAIL")
if res[0] == SystemRunnerResults.LOADED_FROM_PICKLE:
return obj_str + ":\t" + Logger.styled_text(
"Loaded from pickle", "BLUE")
return obj_str + ":\t" + Logger.pp_list(res)
if isinstance(res, ControlLoopOutput):
if res.failed:
return (obj_str + ":\t" +
Logger.styled_text("Failed", "FAIL") + " after " +
Logger.pp_double(res.runtime) + "s, at stance_idx:" +
str(res.end_stance_idx))
return obj_str + ":\tin " + Logger.pp_double(res.runtime) + "s"
return obj_str + ":\t" + str(Logger.pp_double(res))
def remove_visualization(self):
if self.name:
try:
vis.hide(self.name)
except AttributeError:
msg = "Error removing SupportTriangle (" + self.name + ") from klamp't vis"
Logger.log(msg, "FAIL")
def preparar_svc(self, tweets, classificacoes):
# create training and testing vars
x_train, x_test, y_train, y_test = train_test_split(tweets,
classificacoes,
test_size=0.20)
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
self.classificador = Pipeline([('vect', CountVectorizer()),
('tfidf',
TfidfTransformer(use_idf=True,
smooth_idf=True)),
('clf', SVC(kernel='rbf',
C=5,
gamma=0.1))])
self.classificador.fit(x_train, y_train)
mensagem_treino = '\nCLASSIFICADOR SVC TREINADO EM ' + str(
len(x_train)) + ' EXEMPLOS\n'
Logger.ok(mensagem_treino)
accuracy = cross_val_score(self.classificador,
tweets,
classificacoes,
cv=10,
n_jobs=-1)
mensagem_acuracia_10_fold = "\nModelo SVC - ACURÁCIA 10-fold: %0.4f" % (
accuracy.mean())
Logger.ok(mensagem_acuracia_10_fold)
def validate_input_image() -> bool:
if not request.files:
flash(f'Upload an image!')
Logger().error("No file given")
return False
if "filesize" not in request.cookies:
flash(f'Failed to extract the file size from the given image')
Logger().error("Filesize could not be retrieved from input")
return False
if not allowed_image_filesize(request.cookies["filesize"]):
flash(
f'Filesize should be below {app.config["MAX_IMAGE_FILESIZE"]} bytes'
)
Logger().error(
f"Filesize exceeded maximum limit of {app.config['MAX_IMAGE_FILESIZE']} bytes"
)
return False
image = request.files["image"]
if not image.filename:
flash(f'Upload an image')
Logger().error("No filen given")
return False
if not allowed_image(filename=image.filename):
flash(
f'Invalid file extension. Allowed extensions: {app.config["EXTENSIONS_ALLOWED"]}'
)
Logger().error(f"Invalid file extension")
return False
return True
def __init__(self, user):
Session = sessionmaker(bind=engine)
# * Main vars
self.s = Session()
self.user = user
# * Launcher
self.logger = Logger()
def main():
Logger.get_shared_logger().info('main invoked')
Logger.get_shared_logger().info(config)
operator = FileOperationBase(config["src"], config["des"],
config["chunk_size"])
if config["split"]:
operator.split_file()
else:
operator.merge_file()
def __init__(self):
db = MongoClient(host=os.getenv('MONGO_HOST', config.MONGO['host']),
port=int(
os.getenv('MONGO_PORT',
config.MONGO['port']))).inverted_index
self._constants = db.constants
self._index = db.index
self._userdata = db.userdata
self.__logger = Logger().get_logger(__name__)
def xy_centroid_of_intersection(self, support_triangle):
if not type(support_triangle) == type(self):
Logger.log(
"Error in centroid_of_intersection(): o__2DSupportPolygon is not of type __2DSupportPolygon",
"FAIL")
return False
o_poly = support_triangle.get_shapely_poly()
intersection_poly = self.shapely_poly.intersection(o_poly)
return intersection_poly.centroid.coords[0]
def build_list(self, debug=False):
"""
returns runtime
"""
start_t = time.time()
# scatter = self.fs_scatter_obj.get_scatter_list()
world_x = self.x_start
world_y = self.y_start
while world_x <= self.x_end:
while world_y < self.y_end:
try:
cost = self.fs_cost_map.cost_at_xy(world_x, world_y)
z = self.height_map.height_at_xy(world_x, world_y)
# scatter.append((world_x, world_y, z, cost))
self.fs_scatter_obj.append_to_scatter(
(world_x, world_y, z, cost))
except ValueError:
print("value error. world x,y: ", world_x, world_y)
world_y += parameters.Y_STEP_SIZE_FS_SCATTER
world_x += parameters.X_STEP_SIZE_FS_SCATTER
world_y = self.y_start
# Add Starting Leg Positions to scatter
try:
fl_xyz, fr_xyz, br_xyz, bl_xyz = self.get_end_eff_xy_basestate_coords_from_xy_yaw(
self.xy_yaw0)
except ValueError:
Logger.log("Error: robot is outside of search area", "FAIL")
return
fl_xyzc = (fl_xyz[0], fl_xyz[1], fl_xyz[2],
self.fs_cost_map.cost_at_xy(fl_xyz[0], fl_xyz[1]))
fr_xyzc = (fr_xyz[0], fr_xyz[1], fr_xyz[2],
self.fs_cost_map.cost_at_xy(fr_xyz[0], fr_xyz[1]))
br_xyzc = (br_xyz[0], br_xyz[1], br_xyz[2],
self.fs_cost_map.cost_at_xy(br_xyz[0], br_xyz[1]))
bl_xyzc = (bl_xyz[0], bl_xyz[1], bl_xyz[2],
self.fs_cost_map.cost_at_xy(bl_xyz[0], bl_xyz[1]))
self.fs_scatter_obj.append_to_scatter(fl_xyzc, add_to_idx_tree=False)
self.fs_scatter_obj.append_to_scatter(fr_xyzc, add_to_idx_tree=False)
self.fs_scatter_obj.append_to_scatter(br_xyzc, add_to_idx_tree=False)
self.fs_scatter_obj.append_to_scatter(bl_xyzc, add_to_idx_tree=False)
if debug:
print(
f"fs scatter built in: {round(time.time() - start_t,2)} seconds with: {self.fs_scatter_obj.nb_points()} elements"
)
self.fs_scatter_obj.runtime = time.time() - start_t
self.fs_scatter_obj.failed = False
return self.fs_scatter_obj
def __init__(self, project):
self.logger = Logger(__name__).return_logger()
self.project_name = project
self.config_file = 'config_%s.ini' % self.project_name
self.interface_file = '%s.xml' % self.project_name
self.test_file = 'test_%s.py' % self.project_name
self.interface_reader = XMLReader(self.interface_file)
self.tags = self.interface_reader.get_tags()
def func_wrapper(*args, **kwargs):
string = "{state} function {input}"
Logger().info(string.format(state="Started", input=f"{func.__name__}"))
t0 = time.time()
result = func(*args, **kwargs)
time_taken = time.time() - t0
Logger().info(
string.format(
state="Finished",
input=f"{func.__name__} after {time_taken:.3f} seconds"))
return result
def __init__(self):
# * PostgreSQL vars
self.database = PostgreSQL.database
self.host = PostgreSQL.host
self.password = PostgreSQL.password
self.username = PostgreSQL.username
# * Launcher
self.logger = Logger()
self.conn()
self.create_tables()
def __init__(self, book, sheet=0):
"""Read workbook
:param book: work_book name.Not path.
:param sheet: index of sheet or sheet name.
"""
self.logger = Logger(self.__class__.__name__).get_logger()
self.book_name = '{0}\\{1}'.format(DefaultConfig().data_path, book)
self.sheet_locator = sheet
self.book = self._book()
self.sheet = self._sheet()
def support_poly_is_in_intersection_with_other_2d_support_poly(
self, support_triangle, P):
if not type(support_triangle) == type(self):
Logger.log(
"Error in support_poly_is_in_intersection_with_other_2d_support_poly(): o__2DSupportPolygon is not of type __2DSupportPolygon",
"FAIL",
)
return False
o_poly = support_triangle.get_shapely_poly()
intersection_poly = self.shapely_poly.intersection(o_poly)
point = Point(P[0], P[1])
return intersection_poly.contains(point)
def __init__(self):
self.config = get_config()
if not os.isdir("logs"):
os.mkdir("logs")
super().__init__(
command_prefix=self.config["bot"]["prefix"],
intents=discord.Intents.all(),
activity=discord.Game(self.config["bot"]["status"]),
help_command=None,
)
self.discord = Logger.discordLogger()
self.logger = Logger.defaultLogger("EasyGameBot")
self.con = connect_database(self.config["database"]["path"])
def set_q(self, q, debug=False):
torso_x, torso_y, yaw_rads = self.get_torso_xy_yaw(q)
if not torso_x:
return
torso_z = parameters.TORSO_Z_DESIRED
fl_global = self.replace_end_effector_z(self.scatter_list[q[0]][0:3])
fr_global = self.replace_end_effector_z(self.scatter_list[q[1]][0:3])
br_global = self.replace_end_effector_z(self.scatter_list[q[2]][0:3])
bl_global = self.replace_end_effector_z(self.scatter_list[q[3]][0:3])
if debug:
print(" fl_global:", Logger.pp_list(fl_global))
print(" fr_global:", Logger.pp_list(fr_global))
print(" br_global:", Logger.pp_list(br_global))
print(" bl_global:", Logger.pp_list(bl_global))
f_l_r_const = ik.objective(self.f_l,
R=self.get_desired_end_effector_rotation(
1, yaw_rads),
t=fl_global)
f_r_r_const = ik.objective(self.f_r,
R=self.get_desired_end_effector_rotation(
2, yaw_rads),
t=fr_global)
b_l_r_const = ik.objective(self.b_l,
R=self.get_desired_end_effector_rotation(
3, yaw_rads),
t=bl_global)
b_r_r_const = ik.objective(self.b_r,
R=self.get_desired_end_effector_rotation(
4, yaw_rads),
t=br_global)
global_torso_xyz = [torso_x, torso_y, torso_z]
torso_obj = ik.objective(self.torso,
local=[0, 0, 0],
world=global_torso_xyz)
bias_config = utils.nominal_config()
goals = [f_l_r_const, f_r_r_const, b_l_r_const, b_r_r_const, torso_obj]
s = IKSolver(self.robosimian)
for goal in goals:
s.add(goal)
s.setBiasConfig(bias_config)
res = s.solve()
if not res:
return False
return True
def __init__(self, driver, element, window_name=None):
self.logger = Logger(__name__).return_logger()
self.driver = driver
self.Element = element
self.window_open_flag = 0 # 用来标识窗口是否打开
if window_name is not None:
self.window_name = window_name
elif self.driver.name == 'firefox':
self.window_name = u'文件上传'
elif self.driver.name == 'chrome':
self.window_name = u'打开'
elif self.driver.name == 'internet explorer':
self.window_name = u'选择要加载的文件'
def __init__(self,
title,
message=None,
path=None,
server=None,
sender=None,
password=None,
receiver=None):
"""初始化Email
:param title: 邮件标题，必填。
:param message: 邮件正文，非必填。
:param path: 附件路径，可传入list（多附件）或str（单个附件），非必填。
:param server: smtp服务器，如果为空，则读取config.ini中的[email]/server，非必填。
:param sender: 发件人，如果为空，则读取config.ini中的[email]/from，非必填。
:param password: 发件人密码，如果为空，则读取config.ini中的[email]/password，如果读取失败，则需手动输入密码，非必填。
:param receiver: 收件人，如果为空，则读取config.ini中的[email]/to，多收件人用“；”隔开，非必填。
"""
self.logger = Logger(__name__).get_logger()
self.title = title
self.message = message
self.files = path
self.msg = MIMEMultipart('related')
cf = DefaultConfig()
if server:
self.server = server
else:
self.server = cf.get('email', 'server')
if sender:
self.sender = sender
else:
self.sender = cf.get('email', 'from')
if receiver:
self.receiver = receiver
else:
self.receiver = cf.get('email', 'to')
if password:
self.password = password
else:
try:
self.password = cf.get('email', 'pass')
except NoOptionError:
self.password = getpass(
prompt=u'未在config.ini中检测到password，请输入password： ')
def __init__(self, code=None):
"""可传入code进行验证，可不传code生成可用代码证"""
self.logger = Logger(__name__).return_logger()
if not code:
self.code = self.get_an_organization_code()
else:
self.code = code
# bref and check
if '-' in self.code:
self.bref, self.check = self.code.split('-')
else:
self.check = self.code[-1:]
self.bref = self.code[:-1]
def __init__(self):
self.logger = Logger('logs/')
# model
self.model = None
self.optimizer = None
self.lr_scheduler = None
# data
self.train_loader = None
self.test_loader = None
self.val_loader = None
self.train_data = None
self.val_data = None
self.test_data = None
def __init__(self, domain, port):
self.logger = Logger(__name__).get_logger()
self.domain = domain
self.port = port
self.flag = 0 # 连接后置为1
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def get_secret(self, secret_name: str) -> Union[KeyVaultSecret, str]:
try:
return self.client.get_secret(secret_name)
except BaseException as e:
Logger().error(f"{e}")
return ""
def main():
try:
args = get_args()
print(args.config)
config = processing_config(args.config)
except:
print("Missing or invalid arguments")
exit(0)
sess = tf.Session()
model = TinyVGG(config)
model.load(sess)
data = DataGenerator(config)
if config.mode == "prediction":
tester = TinyVGGTester(sess, model, None, config, None)
prediction = tester.predict_image(args.img_path)
print("the input image is of class: ", data.get_label_name(prediction))
return
create_dirs([config.summary_dir, config.checkpoint_dir])
logger = Logger(sess, config)
if config.mode == "train":
print(" train data size: ", data.x_train.shape[0], " val data size: ",
data.x_val.shape[0])
trainer = TinyVGGTrainer(sess, model, data, config, logger)
trainer.train()
elif config.mode == "test":
print(" test data size: ", data.x_test.shape[0])
tester = TinyVGGTester(sess, model, data, config, logger)
tester.test()
else:
print(" Mode: ", config.mode, " is not supported")
def __init__(self, driver, element, window_name=None):
self.logger = Logger(__name__).get_logger()
self.driver = driver
self.Element = element
self.window_open_flag = 0 # 用来标识窗口是否打开
if window_name is not None:
self.window_name = window_name
elif self.driver.name == 'firefox':
self.window_name = u'文件上传'
elif self.driver.name == 'chrome':
self.window_name = u'打开'
elif self.driver.name == 'internet explorer':
self.window_name = u'选择要加载的文件'
def __init__(self, code=None):
"""可传入code进行验证，可不传code生成可用代码证"""
self.logger = Logger(__name__).get_logger()
if not code:
self.code = self.get_an_organization_code()
else:
self.code = code
# bref and check
if '-' in self.code:
self.bref, self.check = self.code.split('-')
else:
self.check = self.code[-1:]
self.bref = self.code[:-1]
def __init__(self, url, method='GET', headers=None, cookie=None):
"""
:param method:
:param headers: Must be a dict. Such as headers={'Content_Type':'text/html'}
"""
self.logger = Logger(__name__).get_logger()
self.url = url
self.session = requests.session()
self.method = method.upper()
self.headers = headers
self.cookie = cookie
self._set_header()
self._set_cookie()
def __init__(self, title, message=None, path=None, server=None, sender=None, password=None, receiver=None):
"""初始化Email
:param title: 邮件标题，必填。
:param message: 邮件正文，非必填。
:param path: 附件路径，可传入list（多附件）或str（单个附件），非必填。
:param server: smtp服务器，如果为空，则读取config.ini中的[email]/server，非必填。
:param sender: 发件人，如果为空，则读取config.ini中的[email]/from，非必填。
:param password: 发件人密码，如果为空，则读取config.ini中的[email]/password，如果读取失败，则需手动输入密码，非必填。
:param receiver: 收件人，如果为空，则读取config.ini中的[email]/to，多收件人用“；”隔开，非必填。
"""
self.logger = Logger(__name__).get_logger()
self.title = title
self.message = message
self.files = path
self.msg = MIMEMultipart('related')
cf = DefaultConfig()
if server:
self.server = server
else:
self.server = cf.get('email', 'server')
if sender:
self.sender = sender
else:
self.sender = cf.get('email', 'from')
if receiver:
self.receiver = receiver
else:
self.receiver = cf.get('email', 'to')
if password:
self.password = password
else:
try:
self.password = cf.get('email', 'pass')
except NoOptionError:
self.password = getpass(prompt=u'未在config.ini中检测到password，请输入password： ')
class TCPClient(object):
def __init__(self, domain, port):
self.logger = Logger(__name__).get_logger()
self.domain = domain
self.port = port
self.flag = 0 # 连接后置为1
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def connect(self):
"""连接指定IP、端口"""
if not self.flag:
try:
self._sock.connect((self.domain, self.port))
self.logger.info('TCPClient connect to {0}:{1} success.'.format(self.domain, self.port))
self.flag = 1
except socket.error as e:
self.logger.exception(e)
def send(self, send_string):
"""向服务器端发送send_string，并返回信息，若报错，则返回None"""
self.connect()
if self.flag:
try:
self._sock.send(send_string)
self.logger.info('TCPClient send "{0}" to server.'.format(send_string))
except socket.error as e:
self.logger.exception(e)
try:
# 没搞清楚 raw-unicode-escape, unicode-escape 区别
rec = self._sock.recv(10240).decode('raw-unicode-escape').encode('utf-8')
self.logger.info('TCPClient get "{0}" from server.'.format(rec))
return rec
except socket.error as e:
self.logger.exception(e)
def close(self):
"""关闭连接"""
if self.flag:
self._sock.close()
self.logger.info('TCPClient closed.')
class XMLReader(object):
def __init__(self, xml):
self.logger = Logger(self.__class__.__name__).get_logger()
self.xml = '{0}\\{1}'.format(DefaultConfig().data_path, xml)
self.tree = self._tree()
self.logger.info('read file: {0}'.format(self.xml))
def _tree(self):
try:
return ElementTree(file=self.xml)
except IOError as e:
raise DataFileNotAvailableException(e)
def get_url(self, tag):
"""Get interface url.
:param tag: xml tag name.
:return: base_url + tag text.
"""
return self.base_url + self.get_text(tag)
def get_text(self, tag):
"""Get tag text.
:param tag: xml tag name or xpath.
:return: tag text.
"""
tree = self.tree
try:
return tree.find(tag).text.strip()
except AttributeError:
raise DataError('\'{0}\' does not have \'{1}\' element.Check your file.'.format(self.xml, tag))
def get_type(self, tag):
"""Get interface type.
:param tag: xml tag name.
:return: interface type.
"""
return self.get_text('.//{0}/type'.format(tag))
def get_method(self, tag):
"""Get interface type.
:param tag: xml tag name.
:return: interface method.
"""
return self.get_text('.//{0}/method'.format(tag))
# todo: 补齐注释
def get_file(self, tag):
return self.get_text('.//{0}/file'.format(tag))
def get_sheet(self, tag):
return self.get_text('.//{0}/sheet'.format(tag))
@property
def base_url(self):
"""Get <Base></Base> text if exists."""
return self.get_text('Base')
def get_tags(self):
base = self.tree.find('Base')
tags = list()
for element in self.tree.getroot().getchildren():
if element != base:
tags.append(element.tag)
return tags
class Email:
"""Email类，读取配置中的基本配置，初始化要求title必填，message与文件路径可选"""
def __init__(self, title, message=None, path=None, server=None, sender=None, password=None, receiver=None):
"""初始化Email
:param title: 邮件标题，必填。
:param message: 邮件正文，非必填。
:param path: 附件路径，可传入list（多附件）或str（单个附件），非必填。
:param server: smtp服务器，如果为空，则读取config.ini中的[email]/server，非必填。
:param sender: 发件人，如果为空，则读取config.ini中的[email]/from，非必填。
:param password: 发件人密码，如果为空，则读取config.ini中的[email]/password，如果读取失败，则需手动输入密码，非必填。
:param receiver: 收件人，如果为空，则读取config.ini中的[email]/to，多收件人用“；”隔开，非必填。
"""
self.logger = Logger(__name__).get_logger()
self.title = title
self.message = message
self.files = path
self.msg = MIMEMultipart('related')
cf = DefaultConfig()
if server:
self.server = server
else:
self.server = cf.get('email', 'server')
if sender:
self.sender = sender
else:
self.sender = cf.get('email', 'from')
if receiver:
self.receiver = receiver
else:
self.receiver = cf.get('email', 'to')
if password:
self.password = password
else:
try:
self.password = cf.get('email', 'pass')
except NoOptionError:
self.password = getpass(prompt=u'未在config.ini中检测到password，请输入password： ')
def _attach_file(self, att_file):
"""内部方法，将单个文件添加到附件列表中"""
att = MIMEText(open('%s' % att_file, 'rb').read(), 'plain', 'utf-8')
att["Content-Type"] = 'application/octet-stream'
filename = re.split(r'[\\|/]', att_file)
att["Content-Disposition"] = 'attachment; filename="%s"' % filename[-1]
self.msg.attach(att)
self.logger.info('attach file {}'.format(att_file))
def send(self):
"""组织邮件内容并发送邮件。"""
self.msg['Subject'] = self.title
self.msg['From'] = self.sender
self.msg['To'] = self.receiver
# 邮件正文
if self.message:
self.msg.attach(MIMEText(self.message))
# 添加附件，支持多个附件（传入list），或者单个附件（传入str）
if self.files:
if isinstance(self.files, list):
for f in self.files:
self._attach_file(f)
elif isinstance(self.files, str):
self._attach_file(self.files)
# 连接服务器并发送
try:
smtp_server = smtplib.SMTP(self.server)
except (gaierror and error) as e:
self.logger.exception(u'发送邮件失败,无法连接到SMTP服务器，检查网络以及SMTP服务器. %s', e)
else:
try:
smtp_server.login(self.sender, self.password)
except smtplib.SMTPAuthenticationError as e:
self.logger.exception(u'用户名密码验证失败！%s', e)
else:
smtp_server.sendmail(self.sender, self.receiver.split(';'), self.msg.as_string())
finally:
smtp_server.quit()
self.logger.info(u'发送邮件"{0}"成功! 收件人：{1}。如果没有收到邮件，请检查垃圾箱，'
u'同时检查收件人地址是否正确'.format(self.title, self.receiver))
def __init__(self, xml):
self.logger = Logger(self.__class__.__name__).get_logger()
self.xml = '{0}\\{1}'.format(DefaultConfig().data_path, xml)
self.tree = self._tree()
self.logger.info('read file: {0}'.format(self.xml))
class FileUpload(object):
def __init__(self, driver, element, window_name=None):
self.logger = Logger(__name__).get_logger()
self.driver = driver
self.Element = element
self.window_open_flag = 0 # 用来标识窗口是否打开
if window_name is not None:
self.window_name = window_name
elif self.driver.name == 'firefox':
self.window_name = u'文件上传'
elif self.driver.name == 'chrome':
self.window_name = u'打开'
elif self.driver.name == 'internet explorer':
self.window_name = u'选择要加载的文件'
def _files(self, files):
"""将files组织成可输入上传文件Edit框的类型
如果传入的是str类型，则不需要组织。
如果传入的是list列表，则需要组织成Edit框接受的格式。（主要是应对多文件上传）
"""
self.files = ''
if type(files) == list:
for f in files:
self.files += '"{0}" '.format(f)
elif type(files) == str:
self.files = files
def _window_open(self):
"""判断窗口标识，如果未打开窗口，则打开上传窗口。"""
if self.window_open_flag == 0:
try:
self.Element.click()
except:
raise UploadWindowOpenError('打开文件上传窗口失败！')
sleep(1)
# 三种方式上传
def upload_by_input(self, files):
"""<input>标签直接send_keys即可。"""
self._files(files)
self.logger.info('upload {} by send_keys'.format(self.files))
self.Element.send_keys(self.files)
def upload_by_win32(self, files):
"""win32方式 —— 打开窗口，并上传文件。（支持多文件上传，files参数传入list）"""
self._window_open()
self._files(files)
self.logger.info('upload {0} by win32'.format(self.files))
upload = win32gui.FindWindow('#32770', self.window_name)
# find Edit
ComboBoxEx32 = win32gui.FindWindowEx(upload, 0, 'ComboBoxEx32', None)
ComboBox = win32gui.FindWindowEx(ComboBoxEx32, 0, 'ComboBox', None)
Edit = win32gui.FindWindowEx(ComboBox, 0, 'Edit', None)
# find confirm button
button = win32gui.FindWindowEx(upload, 0, 'Button', None)
# 验证是否打开窗口
if upload and Edit and button:
self.window_open_flag = 1
else:
raise UploadWindowNotOpenError('未发现上传文件对话框！')
win32gui.SendMessage(Edit, win32con.WM_SETTEXT, 0, self.files)
win32gui.SendMessage(upload, win32con.WM_COMMAND, 1, button)
self.window_open_flag = 0
def upload_by_autoit(self, files):
"""autoit方式 —— 打开窗口，并上传文件（支持多文件上传，files参数传入list）"""
self._window_open()
self._files(files)
self.logger.info('upload {} by autoit'.format(self.files))
# 验证是否打开窗口
if win32gui.FindWindow('#32770', self.window_name):
self.window_open_flag = 1
else:
raise UploadWindowNotOpenError('未发现上传文件对话框！')
upfile = os.path.abspath(DefaultConfig().base_path + '\\src\\resource\\' + AUTOITEXE[self.driver.name])
os.system('{0} {1}'.format(upfile, self.files)) # 调用exe，上传文件
self.window_open_flag = 0
# 统一上传方式
def upload(self, files, autoit=False):
"""综合判断，如果为<input>标签，则直接上传。否则默认用win32方式，如果传入autoit=True，则用autoit上传。"""
if self.Element.tag_name == 'input' and type(files) != list:
self.logger.info('it is a <input> tag.')
self.upload_by_input(files)
elif not autoit:
self.upload_by_win32(files)
else:
self.upload_by_autoit(files)
class HTTPClient(object):
def __init__(self, url, method='GET', headers=None, cookie=None):
"""
:param method:
:param headers: Must be a dict. Such as headers={'Content_Type':'text/html'}
"""
self.logger = Logger(__name__).get_logger()
self.url = url
self.session = requests.session()
self.method = method.upper()
self.headers = headers
self.cookie = cookie
self._set_header()
self._set_cookie()
def _set_header(self):
"""设置header"""
if self.headers:
self.session.headers.update(self.headers)
self.logger.info('Set headers: {0}'.format(self.headers))
def _set_cookie(self):
"""设置cookie"""
if self.cookie:
self.session.cookies.update(self.cookie)
self.logger.info('Set cookies: {0}'.format(self.cookie))
def _check_method(self):
"""检查传入的method是否可用。"""
if self.method not in METHODS:
self.logger.exception(UnSupportMethod(u'不支持的method:{0}，请检查传入参数！'.format(self.method)))
else:
return True
def send(self, params=None, data=None, **kwargs):
"""send request to url.If response 200,return response, else return None."""
if self._check_method():
response = self.session.request(method=self.method, url=self.url, params=params, data=data, **kwargs)
self.logger.info('{0} {1}.'.format(self.method, self.url))
if response.status_code == 200:
self.logger.info('request success: {0}\n{1}'.format(response, response.content.strip()))
return response
else:
self.logger.error('request failed: {0} {1}'.format(response, response.reason))
class OrganizationCode(object):
"""组织机构代码证支持类。支持生成随机代组织码证以及验证组织机构代码证。"""
ORGANIZATION_CODE_MAP = string.digits + string.ascii_uppercase
WMap = [3, 7, 9, 10, 5, 8, 4, 2]
def __init__(self, code=None):
"""可传入code进行验证，可不传code生成可用代码证"""
self.logger = Logger(__name__).get_logger()
if not code:
self.code = self.get_an_organization_code()
else:
self.code = code
# bref and check
if '-' in self.code:
self.bref, self.check = self.code.split('-')
else:
self.check = self.code[-1:]
self.bref = self.code[:-1]
def _get_c9(self):
"""获取组织机构代码证的最后一位验证码 —— c9"""
# C9=11-MOD（∑Ci(i=1→8)×Wi,11）
sum = 0
for ind, i in enumerate(self.bref):
ci = self.ORGANIZATION_CODE_MAP.index(i)
wi = self.WMap[ind]
sum += ci * wi
c9 = 11 - (sum % 11)
if c9 == 10:
c9 = 'X'
elif c9 == 11:
c9 = '0'
return str(c9)
def get_an_organization_code(self):
"""生成机构代码证并返回"""
self.bref = random_string(8).upper()
c9 = self._get_c9()
organization_code = '{0}-{1}'.format(self.bref, c9)
self.logger.info('生成组织机构代码证 {0}'.format(organization_code))
return organization_code
def check_organization_code(self):
"""检查组织机构代码证是否正确，如果正确，返回True，否则返回False"""
if len(self.bref) != 8 or len(self.check) != 1:
self.logger.info('组织机构代码证错误!（本体或校验码长度不符合要求）')
return False
else:
try:
c9_right = self._get_c9()
if self.check != c9_right:
self.logger.info('组织机构代码证错误!（校验码错误）')
return False
else:
self.logger.info('验证通过，组织机构代码证格式正确！')
return True
except ValueError:
self.logger.info('组织机构代码证错误!(本体错误)')
return False
