def test_func(self):
"""
临时用的测试方法
:return:
"""
left_arr = [
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/1.mov",
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/2.mov",
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/3.mov",
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/4.mov",
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/5.mov",
"/Users/qinbaomac-mini/Desktop/output/test-rename/1111/1234234321423/6.mov"
]
# left_arr = ["/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d6.mp3",
# "/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d4.mp3",
# "/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d5.mp3",
# "/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d1.mp3",
# "/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d2.mp3",
# "/Users/qinbaomac-mini/Desktop/output/111/1111/1234234321423/yw_d21_d3.mp3"
# ]
right_arr = [
"d21_d1", "d21_d2.mp3", "d21_d3.mp3", "d21_d4.mp3", "d21_d5.mp3",
"d21_d6.mp3"
]
self.svL.set(left_arr)
self.svR.set(right_arr)
utils.set_state(self.start_btn, True)
def callback_query_constructor_callback(bot: Bot, update: Update, user_data: dict):
prepare_user_data(update, user_data)
delete_keyboard = True
new_state = None
if user_data["node"] == -10:
if update.callback_query.data == "add_buttons":
new_state = adding_inline_keyboard_hint(bot, user_data)
elif update.callback_query.data == "del_buttons":
save_post_draft(user_data, update.callback_query.message.to_json())
new_state = post_preview(bot, user_data)
elif user_data["node"] == -11:
if update.callback_query.data == "cancel":
new_state = post_preview(bot, user_data)
elif user_data["node"] == -12:
if update.callback_query.data == "publish":
save_post(user_data, 0)
broadcast_post(bot, copy.deepcopy(user_data), *parse_post_to_send(user_data["post_id"]))
del user_data["post_id"]
destruct_constructor_handlers(user_data)
new_state = broadcast_post_hint(bot, user_data)
elif update.callback_query.data == "delay":
new_state = delay_post_broadcasting(bot, user_data)
elif update.callback_query.data == "go_back":
new_state = post_preview(bot, user_data)
if new_state is not None:
set_state(user_data["id"], user_data, new_state)
if delete_keyboard:
bot.edit_message_reply_markup(message_id=update.callback_query.message.message_id,
chat_id=user_data["chat_id"])
bot.answer_callback_query(update.callback_query.id)
raise DispatcherHandlerStop
def set_to_object(self, obj):
"""Sets the workflow to the passed object.
If the object has already the given workflow nothing happens. Otherwise
the workflow is set to the objectthe state is set to the workflow's
initial state.
**Parameters:**
obj
The object which gets the workflow.
"""
import utils
ctype = ContentType.objects.get_for_model(obj)
try:
wor = WorkflowObjectRelation.objects.get(content_type=ctype, content_id=obj.id)
except WorkflowObjectRelation.DoesNotExist:
WorkflowObjectRelation.objects.create(content = obj, workflow=self)
utils.set_state(obj, self.initial_state)
else:
if wor.workflow != self:
wor.workflow = self
wor.save()
utils.set_state(self.initial_state)
def test_process_message():
# start command
message, finished = utils.process_message('test', '/start')
assert message == constants.questions['start']['message']
assert not finished
# message without start
utils.set_state('test', '')
message, finished = utils.process_message('test', 'some message')
assert message == constants.WELCOME
assert not finished
def user_entering_name(message):
if not message.text.isdigit():
bot.send_message(message.chat.id, "Что-то не так, попробуй ещё раз!")
return
else:
bot.send_message(message.chat.id, "Ваш запрос обробатывается....")
utils.set_vk_id(message.from_user.id, message.text)
utils.set_state(message.from_user.id, utils.States.S_DOWNLOADING.value)
music_data = vkaudio.get(int(message.text))
d = Downloader(music_data)
d.download_music(bot, message.chat.id)
def main():
#time_step = 0.0002 # TODO: context.get_continuous_state_vector() fails
time_step = 2e-3
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--cfree', action='store_true',
help='Disables collisions when planning')
parser.add_argument('-d', '--deterministic', action='store_true',
help='Manually sets the random seeds used by the stream generators')
parser.add_argument('-s', '--simulate', action='store_true',
help='Simulates the system')
args = parser.parse_args()
if args.deterministic:
# TODO: still not fully deterministic
random.seed(0)
np.random.seed(0)
import meshcat
meshcat_vis = meshcat.Visualizer()
task, diagram, state_machine = load_station(time_step=time_step)
print(task)
plant = task.mbp
#dump_plant(plant)
#dump_models(plant)
RenderSystemWithGraphviz(diagram) # Useful for getting port names
context = diagram.GetMutableSubsystemContext(plant, task.diagram_context)
task.publish()
initial_state = get_state(plant, context)
trajectories = plan_trajectories(task, context, collisions=not args.cfree)
if trajectories is None:
return
##################################################
set_state(plant, context, initial_state)
if args.simulate:
from manipulation_station.robot_plans import JointSpacePlan
splines, gripper_setpoints = convert_splines(plant, task.robot, task.gripper, context, trajectories)
sim_duration = compute_duration(splines)
plan_list = [JointSpacePlan(spline) for spline in splines]
print('Splines: {}\nDuration: {:.3f} seconds'.format(len(splines), sim_duration))
task, diagram, state_machine = load_station(time_step=time_step, plan=(plan_list, gripper_setpoints))
task.set_initial()
#set_state(plant, context, initial_state)
#state_machine.Load(plan_list, gripper_setpoints)
simulate_splines(task.diagram, task.diagram_context, sim_duration)
else:
step_trajectories(diagram, task.diagram_context, context, trajectories, time_step=0.001)
def constructor_callback(bot: Bot, update: Update, job_queue, user_data: dict):
prepare_user_data(update, user_data)
new_state = None
if user_data["node"] in (-9, -10, -12):
if update.message.text is not None:
if update.message.text == "Отменить":
delete_post(user_data)
destruct_constructor_handlers(user_data)
new_state = admin_welcome(bot, user_data)
elif update.message.text == "Очистить":
delete_post(user_data)
new_state = post_constructor_first_step(bot, user_data)
elif update.message.text == "Предпросмотр":
new_state = post_preview(bot, user_data, False)
elif update.message.text == "Далее":
if user_data.get("post_id") is not None:
new_state = sending_post_settings(bot, user_data)
else:
new_state = empty_msg(bot, user_data, -9, "Невозможно разослать пустое сообщение")
else:
save_post_draft(user_data, update.message.to_json())
new_state = post_preview(bot, user_data)
else:
save_post_draft(user_data, update.message.to_json())
new_state = post_preview(bot, user_data)
elif user_data["node"] == -11:
reply_markup = make_reply_markup(update.message.text)
if reply_markup is not None:
save_post_draft(user_data, None, reply_markup.to_json())
new_state = post_preview(bot, user_data)
else:
new_state = error_during_buttons_adding(bot, user_data)
elif user_data["node"] == -13:
delay = parse_delay(update.message.text)
if delay is not None:
job_queue.run_once(
callback=delayed_broadcasting_job_callback,
when=delay*60, # from minutes to seconds
context=(copy.deepcopy(user_data), *parse_post_to_send(user_data["post_id"]))
)
save_post(user_data, delay)
del user_data["post_id"]
destruct_constructor_handlers(user_data)
new_state = broadcast_post_hint(bot, user_data)
else:
new_state = error_during_delay_parsing(bot, user_data)
if new_state is not None:
set_state(user_data["id"], user_data, new_state)
raise DispatcherHandlerStop
def test(model, test_set, env, xm, xs, am, ast, render=False):
successes, failures = 0, 0
for i in range(len(test_set)):
succeded = 0
env.reset()
env = utils.set_state(env, test_set[i][0], test_set[i][1])
state, *_ = env.step([0., 0., 0., 0.])
picked = [False]
for i in range(100):
action = model((np.concatenate(
(state["observation"], state["achieved_goal"],
state["desired_goal"])).reshape((1, -1)) - xm) / xs)
action = action * ast + am
new_state, *_ = env.step(action[0])
# print(action)
if render: env.render()
state = new_state
if not np.linalg.norm(
(state["achieved_goal"] - state["desired_goal"])) > 0.07:
# print("SUCCESS!")
succeded = 1
successes += 1
break
if not succeded:
# print("FAILURE")
failures += 1
return successes, failures
def test(model, ae, test_set, env, xm, xs, am, ast, fulltraj = False, render = False):
successes, failures = 0,0
error_succ, error_fail = 0.,0.
succ_errors_list, fail_errors_list = [], []
for i in range(len(test_set)):
succeded = 0
env.reset()
env = utils.set_state(env, test_set[i][0], test_set[i][1])
state, *_ = env.step([0.,0.,0.,0.])
picked = [False]
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
tot_error = error
#print("Uncertainty ", error.numpy())
for i in range(100):
action = model((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
action = action*ast + am
new_state, *_ = env.step(action[0])
# print(action)
if render: env.render()
state = new_state
if fulltraj:
#If I choose to sum up the errors of the entire trajectory I integrate errors
# on tot_error
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
tot_error+=error
if not np.linalg.norm((state["achieved_goal"]- state["desired_goal"])) > 0.07:
# print("SUCCESS!")
succeded = 1
successes +=1
#divide by number of steps to get an average
if fulltraj:
error_succ += tot_error/(i + 1)
succ_errors_list.append(tot_error/(i + 1))
else:
error_succ += tot_error
succ_errors_list.append(tot_error)
break
if not succeded:
# print("FAILURE")
failures+=1
#divide by number of steps to get an average
if fulltraj:
error_fail += tot_error/(i + 1)
fail_errors_list.append(tot_error/(i+1))
else:
error_fail += tot_error
fail_errors_list.append(tot_error)
return successes, failures, error_succ/successes, error_fail/failures, succ_errors_list, fail_errors_list
def leave_right(self, event):
"""移出右侧粘贴框
"""
if self.hasQuery:
return
ss = self.paste_r.get(1.0, tk.END)
arr = utils.split_str(ss, False)
if len(arr) and arr[0] == self.msg_right:
# print("默认")
return
# 如果是文件路径，则取出文件名和扩展名 / 文件夹名
narr = []
for i in range(len(arr)):
arr[i] = utils.pathlib_path(arr[i])
item = arr[i]
item = item.strip("\t").strip(" ")
item = item.strip("\t").strip(" ")
item = item.strip('"').strip("'")
p = Path(item)
if p.name:
narr.append(p.name)
if not len(narr):
self.paste_r.delete(1.0, tk.END)
self.paste_r.insert(tk.INSERT, self.msg_right)
return
# self.varR.set(tuple(narr))
# self.varC.set(tuple([]))
self.svR.set(narr)
self.svC.set([])
self.sortRS['text'] = self.sortDesc[0]
self.RightIsReverse = False
# vlstr = self.varL.get()
# vrstr = self.varR.get()
# varIsN = util.stringVarisN
# if varIsN(vlstr) or varIsN(vrstr):
validL = self.svL.is_null()
validR = self.svR.is_null()
if not validL or not validR:
utils.set_state(self.start_btn, True)
self.paste_r.delete(1.0, tk.END)
self.paste_r.insert(tk.INSERT, self.msg_right)
def get_active_exp(env, threshold, ae, xm, xs, render, take_max = False, max_act_steps = 20):
err_avg = 0
for i in range(20):
state = env.reset()
state = robot_reset(env)
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
err_avg+=error
err_avg/=20
state = env.reset()
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
#print("predicted error", error)
if not take_max:
tried = 0
while not error > threshold*err_avg:
tried+=1
state = env.reset()
state = robot_reset(env)
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
# print("predicted error", error.numpy(), err_avg.numpy())
# print("Tried ", tried, " initial states")
new_states, new_acts = man_controller.get_demo(env, state, CTRL_NORM, render)
return new_states, new_acts
else:
errs_states = []
for k in range(max_act_steps):
state = env.reset()
state = robot_reset(env)
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
s, g = utils.save_state(env)
errs_states.append([s, g, error])
max_error = -1000
max_key = ()
for el in range(len(errs_states)):
if errs_states[el][2] > max_error:
max_error = errs_states[el][2]
max_key = el
new_env = utils.set_state(env, errs_states[max_key][0], errs_states[max_key][1])
state, *_ = new_env.step(np.zeros(4))
new_states, new_acts = man_controller.get_demo(new_env, state, CTRL_NORM, render)
return new_states, new_acts
def delay_off(minutes):
time.sleep(60*minutes)
set_state({"mode": "off"})
def test_states():
utils.set_state('test', 'test_state')
assert utils.get_current_state('test') == 'test_state', '1st state saving failed'
utils.set_state('test', 'test_state2')
assert utils.get_current_state('test') == 'test_state2', '2nd state saving failed'
def state_view():
if request.method == "POST":
state = request.json.get("state")
set_state(state)
print(state)
return jsonify(get_state())
def button_callback():
date_time = datetime.datetime.now().strftime("%m/%d/%Y, %H:%M:%S")
post_message_to_lack(f"@here button pressed! `{date_time}`")
set_state({"mode": "nyan_cat"})
time.sleep(10)
set_state({"mode": "per_step"})
def paste_leave_left(self, event):
"""移出左侧粘贴框
"""
if self.hasQuery:
return
ss = self.paste_l.get(1.0, tk.END)
arr = utils.split_str(ss, False)
if len(arr) and arr[0] == self.msgLeft:
# print("默认")
return
# 检查文件/文件夹是否存在
narr = []
no_exists_arr = []
for i in range(len(arr)):
arr[i] = utils.pathlib_path(arr[i])
item = arr[i]
if len(item) < 3:
continue
if os.path.exists(item):
narr.append(item)
else:
no_exists_arr.append(item)
if not len(narr):
self.paste_l.delete(1.0, tk.END)
self.paste_l.insert(tk.INSERT, self.msgLeft, "right")
return
# 去重
tarr = []
for item in narr:
if not tarr.count(item):
tarr.append(item)
narr = tarr
# self.varL.set(tuple(narr))
# self.varC.set(tuple([]))
self.svL.set(narr)
self.svC.set([])
self.sortLS['text'] = self.sortDesc[0]
self.LeftIsReverse = False
self.list_l.xview_moveto(1.0)
# vlstr = self.varL.get()
# vrstr = self.varR.get()
# validL = False if util.stringVarisN(vlstr) else True
# validR = False if util.stringVarisN(vrstr) else True
validL = False if self.svL.is_null() else True
validR = False if self.svR.is_null() else True
if validL and validR:
utils.set_state(self.start_btn, True)
self.paste_l.delete(1.0, tk.END)
self.paste_l.insert(tk.INSERT, self.msgLeft, "right")
num1 = len(no_exists_arr)
if num1:
file_name_str = "\n".join(str(item) for item in no_exists_arr)
utils.showinfo('{0}个文件不存在，将不参与重命名：{1}\n'.format(
num1, file_name_str))
def manual_int(self):
if self.is_manual_int:
return
self.is_manual_int = True
win = self.win
self.hasQuery = False
self.LeftIsReverse = False
self.RightIsReverse = False
self.sortDesc = ('排序↕', "升序a-z", '降序z-a')
"""组装 ui
"""
# 颜色
GRAP = "#515556"
# GRAP2 = "#B9BFC1"
# TXT_BG = "#ECECEC"
LIST_BG = "#EFEFEF"
LIST_WIDTH = 91 + 10
# TXT_WIDTH = 80+7
# FILE_GAP = 65+10
# WRAP_LENGTH = 780
frame = tk.Frame(win, padx=8, pady=2)
frame.grid(column=1, row=0, sticky=tk.N + tk.S + tk.W)
self.svL = StringVar()
self.svC = StringVar()
self.svR = StringVar()
varL = self.svL.get_object()
varC = self.svC.get_object()
varR = self.svR.get_object()
self.list_l = tk.Listbox(frame,
selectmode=tk.EXTENDED,
fg=GRAP,
background=LIST_BG,
height=20,
setgrid=1,
activestyle='none')
self.list_c = utils.clone(self.list_l)
self.list_r = utils.clone(self.list_l)
self.list_l.config(yscrollcommand=self.yscroll1, listvariable=varL)
self.list_c.config(yscrollcommand=self.yscroll2, listvariable=varC)
self.list_r.config(yscrollcommand=self.yscroll3, listvariable=varR)
self.list_l.config(bd=1, justify=tk.RIGHT, width=LIST_WIDTH - 35)
self.list_c.config(bd=0, justify=tk.CENTER, width=7)
self.list_r.config(bd=1, justify=tk.LEFT, width=25)
self.list_l.grid(column=1, row=10, sticky=tk.E)
self.list_c.grid(column=2, row=10, sticky=tk.W)
self.list_r.grid(column=3, row=10, sticky=tk.W)
self.scrollbar = tk.Scrollbar(frame,
orient='vertical',
command=self.yview)
self.scrollbar.grid(column=4, row=10, sticky=tk.N + tk.S + tk.W)
# test
# for x in range(30):
# self.list_l.insert('end', x)
# self.list_r.insert('end', x)
self.msgLeft = " ;-) 点我 粘贴 需命名的文件"
self.paste_l = tk.Text(frame,
height=1,
width=LIST_WIDTH - 30,
fg=GRAP,
wrap=tk.WORD,
font=setting_fftool.font_default)
self.paste_l.bind("<Leave>", self.paste_leave_left)
self.paste_l.bind("<Button-1>", self.pasteClick)
self.paste_l.tag_config("right", justify=tk.RIGHT)
self.paste_l.insert(tk.INSERT, self.msgLeft, "right")
self.msg_right = " ;-) 粘贴 文件名 或 文件"
self.paste_r = tk.Text(frame,
height=1,
width=25,
fg=GRAP,
wrap=tk.WORD,
font=setting_fftool.font_default)
self.paste_r.bind("<Leave>", self.leave_right)
self.paste_r.bind("<Button-1>", self.pasteClick)
self.paste_r.insert(tk.INSERT, self.msg_right)
self.paste_l.grid(column=1, row=0, sticky=tk.NE)
self.paste_r.grid(column=3, row=0, sticky=tk.NW)
# 左右排序按钮
fleft = tk.Frame(frame, padx=8, pady=2)
fRight = tk.Frame(frame, padx=8, pady=2)
desc = self.sortDesc
self.sortLS = tk.Button(fleft, text=desc[0], width=7)
self.sortLU = tk.Button(fleft, text='↑', width=2)
self.sortLD = tk.Button(fleft, text='↓', width=2)
self.sortRS = tk.Button(fRight, text=desc[0], width=7)
self.sortRU = tk.Button(fRight, text='↑', width=2)
self.sortRD = tk.Button(fRight, text='↓', width=2)
widgets = (self.sortLS, self.sortLU, self.sortLD, self.sortRS,
self.sortRU, self.sortRD)
for w in widgets:
utils.bind(w, self.sortCall)
fleft.grid(column=1, row=5, sticky=tk.NE)
self.sortLS.grid(column=4, row=1)
self.sortLU.grid(column=2, row=1)
self.sortLD.grid(column=3, row=1)
fRight.grid(column=3, row=5, sticky=tk.NE)
self.sortRS.grid(column=1, row=1)
self.sortRU.grid(column=2, row=1)
self.sortRD.grid(column=3, row=1)
start_btn = tk.Button(frame,
text='开始\n命名',
width=6,
height=3,
command=self.start_check,
relief=tk.GROOVE)
undo_btn = tk.Button(frame,
text='↺撤销',
width=6,
height=1,
command=self.start_check,
relief=tk.GROOVE)
start_btn.grid(column=2, row=20)
undo_btn.grid(column=2, row=21)
utils.set_state(start_btn, False)
utils.set_state(undo_btn, False)
# 统一设置样式
tub1 = (self.list_l, self.list_r, start_btn, undo_btn)
tub = widgets + tub1
utils.set_groove(tub)
self.undo_btn = undo_btn
self.start_btn = start_btn
def set_state(self, state):
"""Sets the workflow state of the object.
"""
return utils.set_state(self, state)
def set_state(self, boo):
utils.set_state(self.start_btn, boo)
def predict(model, ae, test_set, env, xm, xs, am, ast, tot_error_trainset):
succ_tp, succ_fp, succ_tn, succ_fn = 0,0,0,0
successes, failures = 0, 0
steps_to_stop = []
for i in range(len(test_set)):
steps = 0
env.reset()
env = utils.set_state(env, test_set[i][0], test_set[i][1])
state, *_ = env.step([0.,0.,0.,0.])
picked = [False]
succeded = False
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
# If not FULL_TRAJ predict directly the outcome. Otherwise, predict success and eventually
# correct to failure if the error becomes too high.
if not FULL_TRAJ:
if error > tot_error_trainset:
prediction = "failure"
else:
prediction = "success"
else: prediction = "success"
# prediction = "success" #assume you think you'll always succeed
for i in range(100):
if prediction == "success": steps+=1
action = model((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
action = action*ast + am
new_state, *_ = env.step(action[0])
if RENDER_TEST: env.render()
if FULL_TRAJ:
# Checks at every step if the error becomes too high.
error = ae.error((np.concatenate((state["observation"],
state["achieved_goal"],
state["desired_goal"])).reshape((1,-1)) - xm)/xs)
if error > ERROR_THR_PRED*tot_error_trainset:
prediction = "failure"
#print("PREDICTED FAILURE")
#print(np.random.randn())
#break #Should not break, because it could solve it even if it thinks it won't
state = new_state
if not np.linalg.norm((state["achieved_goal"]- state["desired_goal"])) > 0.07:
# print("SUCCESS!")
successes += 1
succeded = True
if prediction == "success":
succ_tp +=1
elif prediction == "failure":
succ_fn +=1
break
#divide by number of steps to get an average
# if FULL_TRAJ: print("End \n \n \n")
if not succeded:
failures += 1
if prediction == "failure":
succ_tn +=1
steps_to_stop.append(steps)
elif prediction == "success":
succ_fp += 1
print("successes, failures", successes, failures)
print("steps to stop", steps_to_stop, np.array(steps_to_stop).mean())
return succ_tp, succ_fp, succ_tn, succ_fn
