def main():
zoom = Zoom(ZOOM_API_KEY, ZOOM_API_SECRET)
jwt_token: bytes = bytes(JWT_TOKEN, encoding='utf8')
response: Response = zoom.get_meeting_participants(ZOOM_MEETING_ID,
jwt_token)
print(response)
list_of_participants: List[dict] = response.json().get("participants")
while token := response.json().get("next_page_token"):
response = zoom.get_meeting_participants(ZOOM_MEETING_ID, jwt_token,
token)
list_of_participants += response.json().get("participants")
def __init__(self):
# SpreadSheet
logger.info('--- Initialize Spreadsheet')
self.mysheet = Sheet()
# Google Drive
logger.info('--- Initialize Google Drive')
self.mydrive = GDrive()
# Slack
# logger.info('--- Initialize Slack')
# self.slack = Slack()
# Zoom
logger.info('--- Initialize Zoom')
self.zoom = Zoom()
async def spam(meeting_id: int, password: str, username: str, message: str,
url: str):
"""
Спамит сообщениями в чат
:param meeting_id: номер конференции
:param password: пароль конференции
:param username: ник бота
:param message: сообщение
:param url: ссылка на конференцию
"""
zoom = Zoom(url, username)
logger.debug(_("Joining meeting {meeting_id} with password {password}"),
meeting_id=meeting_id,
password=password)
while True:
try:
meeting = await zoom.join_meeting(meeting_id, password)
async with meeting as ws:
logger.info(_("{username}: Started sending messages..."),
username=username)
while True:
try:
await ws.get_message()
text = b64encode(message.encode()).decode()
await ws.send_message(
zoom.create_payload(4135, {
"text": text,
"destNodeID": 0
}))
except WrongPasswordError:
logger.warning(
_("Server: wrong password, ignoring..."))
continue
except (ClosedResourceError, ConnectionClosed,
AttributeError):
logger.warning(
_("Server closed connection, trying again..."))
await trio.sleep(3)
break
except (ClosedResourceError, ConnectionClosed, AttributeError):
logger.warning(_("Server closed connection, trying again..."))
await trio.sleep(3)
pass
async def spam(meeting_id: int, password: str, username: str, message: str):
zoom = Zoom(username)
meeting = await zoom.join_meeting(meeting_id, password)
async with meeting as websocket:
while True:
await websocket.recv()
text = b64encode(message.encode()).decode()
await websocket.send(
json.dumps({
"evt": 4135,
"body": {
"text": text,
"destNodeID": 0
},
"seq": 0
}))
from googl import Googl
from zoom import Zoom
ZOOM_API_KEY = os.environ.get("ZOOM_API_KEY")
ZOOM_API_SECRET = os.environ.get("ZOOM_API_SECRET")
ZOOM_MEETING_ID = os.environ.get("ZOOM_MEETING_ID")
SERVICE_ACCOUNT_FILE = f".secrets/{os.listdir('.secrets')[0]}"
SCOPES = [
"https://www.googleapis.com/auth/drive",
"https://www.googleapis.com/auth/drive.file"
]
if __name__ == "__main__":
zoom = Zoom(ZOOM_API_KEY, ZOOM_API_SECRET)
jwt_token: bytes = zoom.generate_jwt_token()
response: Response = zoom.get_meeting_participants(ZOOM_MEETING_ID,
jwt_token)
list_of_participants: List[dict] = response.json().get("participants")
while token := response.json().get("next_page_token"):
response = zoom.get_meeting_participants(ZOOM_MEETING_ID, jwt_token,
token)
list_of_participants += response.json().get("participants")
df: DataFrame = pd.DataFrame(list_of_participants).drop(
columns=["attentiveness_score"])
df.join_time = pd.to_datetime(
df.join_time).dt.tz_convert("Australia/Sydney")
def __init__(self):
self.builder = Gtk.Builder()
self.builder.add_from_file(const.MAIN_PROG_FOLDER + const.UI_FOLDER +
"main_ui.glade")
handlers = {
"on_open": self.on_open,
"on_quit": self.on_quit,
"run_fpga": self.run_fpga,
"run_histopac": self.run_histopac, ###change to self.run_histopac
"run_anizpac": self.run_anizpac, ###change to self.run_anizpac
"run_pypac_signal": self.run_pypac_signal,
"edit_config": self.edit_config,
"edit_constants": self.edit_constants,
"on_start": self.on_start,
"on_stop": self.on_stop,
"on_save": self.on_save,
"on_pause": self.on_pause,
"on_clear": self.on_clear,
"zoom_en_shrink": self.z_en_shrink,
"zoom_en_squeeze": self.z_en_squeeze,
"zoom_en_left": self.z_en_mov_l,
"zoom_en_right": self.z_en_mov_r,
"zoom_en_up": self.z_en_up,
"zoom_en_down": self.z_en_down,
"zoom_en_log": self.z_en_log,
"zoom_en_zero": self.z_en_zero,
"zoom_t_shrink": self.z_t_shrink,
"zoom_t_squeeze": self.z_t_squeeze,
"zoom_t_left": self.z_t_left,
"zoom_t_right": self.z_t_right,
"zoom_t_down": self.z_t_down,
"zoom_t_up": self.z_t_up,
"zoom_t_log": self.z_t_log
}
self.builder.connect_signals(handlers)
self.main_win = self.builder.get_object("main_win")
self.init_Figs()
main_grid = self.builder.get_object("main_grid")
self.attach_Figs(main_grid)
#tmp_foldername = "/home/das/job/plis/histo/apr14_4det_porog=90_delay=100_coinc_10h_night"
self.curr_histo_folder = const.DEFAULT_CURR_HISTO_FOLDER
self.spectra = Spectra(self.curr_histo_folder)
self.fill_Figs(self.spectra.histo)
zoom_args = {
"en_magnification": 1e2,
"en_v_step": 5e3,
"en_h_step": 1e2,
"t_magnification": 1e2,
"t_v_step": 1e3,
"t_h_step": 100.0
}
self.zoom = Zoom(self.en_fig, self.t_fig, self.en_axes, self.t_axes,
zoom_args)
self.logger = Logger(path.join(const.MAIN_PROG_FOLDER, "journal.log"))
self.logger.info("Program initialization OK")
self.update_counts([0] * 4)
self.info_textview = self.builder.get_object("info_textview")
self.information = Information(self.info_textview)
self.statusbar = self.builder.get_object("main_statusbar")
class UI():
def __init__(self):
self.builder = Gtk.Builder()
self.builder.add_from_file(const.MAIN_PROG_FOLDER + const.UI_FOLDER +
"main_ui.glade")
handlers = {
"on_open": self.on_open,
"on_quit": self.on_quit,
"run_fpga": self.run_fpga,
"run_histopac": self.run_histopac, ###change to self.run_histopac
"run_anizpac": self.run_anizpac, ###change to self.run_anizpac
"run_pypac_signal": self.run_pypac_signal,
"edit_config": self.edit_config,
"edit_constants": self.edit_constants,
"on_start": self.on_start,
"on_stop": self.on_stop,
"on_save": self.on_save,
"on_pause": self.on_pause,
"on_clear": self.on_clear,
"zoom_en_shrink": self.z_en_shrink,
"zoom_en_squeeze": self.z_en_squeeze,
"zoom_en_left": self.z_en_mov_l,
"zoom_en_right": self.z_en_mov_r,
"zoom_en_up": self.z_en_up,
"zoom_en_down": self.z_en_down,
"zoom_en_log": self.z_en_log,
"zoom_en_zero": self.z_en_zero,
"zoom_t_shrink": self.z_t_shrink,
"zoom_t_squeeze": self.z_t_squeeze,
"zoom_t_left": self.z_t_left,
"zoom_t_right": self.z_t_right,
"zoom_t_down": self.z_t_down,
"zoom_t_up": self.z_t_up,
"zoom_t_log": self.z_t_log
}
self.builder.connect_signals(handlers)
self.main_win = self.builder.get_object("main_win")
self.init_Figs()
main_grid = self.builder.get_object("main_grid")
self.attach_Figs(main_grid)
#tmp_foldername = "/home/das/job/plis/histo/apr14_4det_porog=90_delay=100_coinc_10h_night"
self.curr_histo_folder = const.DEFAULT_CURR_HISTO_FOLDER
self.spectra = Spectra(self.curr_histo_folder)
self.fill_Figs(self.spectra.histo)
zoom_args = {
"en_magnification": 1e2,
"en_v_step": 5e3,
"en_h_step": 1e2,
"t_magnification": 1e2,
"t_v_step": 1e3,
"t_h_step": 100.0
}
self.zoom = Zoom(self.en_fig, self.t_fig, self.en_axes, self.t_axes,
zoom_args)
self.logger = Logger(path.join(const.MAIN_PROG_FOLDER, "journal.log"))
self.logger.info("Program initialization OK")
self.update_counts([0] * 4)
self.info_textview = self.builder.get_object("info_textview")
self.information = Information(self.info_textview)
self.statusbar = self.builder.get_object("main_statusbar")
def create_t_title(self, i):
titles = [
"D1-D2", "D2-D1", "D1-D3", "D3-D1", "D1-D4", "D4-D1", "D2-D3",
"D3-D2", "D2-D4", "D4-D2", "D3-D4", "D4-D3"
]
return titles[i]
def init_Figs(self):
def format_yticks(y, pos):
threshold_divider = 300
if y < threshold_divider:
return "{:.0f}".format(y)
else:
return "{:.1f}k".format(y / 1e3)
self.en_fig = []
self.en_axes = []
for i in range(0, const.DET_NUM):
self.en_fig.append(Figure(figsize=(1, 1), dpi=80, frameon=False))
self.en_axes.append(self.en_fig[i].add_subplot(111))
###adjust subplots to specific size
if i == 0:
self.en_fig[i].subplots_adjust(left=0.2,
bottom=0.05,
right=0.99,
top=0.97)
else:
self.en_fig[i].subplots_adjust(left=0.05,
bottom=0.05,
right=0.99,
top=0.97)
###
###xlim ylim
self.en_axes[i].set_xlim(0, const.HIST_SIZE)
self.en_axes[i].set_ylim(bottom=-1)
###
###x, y ticks
self.en_axes[i].set_xticks([0, 1000, 2000, 3000, 4000])
self.en_axes[i].minorticks_on()
# self.en_axes[i].xaxis.set_major_formatter( FuncFormatter(lambda x, pos: "{:.0f}k".format(x/1e3)) )
if i == 0:
self.en_axes[i].yaxis.set_major_formatter(
FuncFormatter(format_yticks))
else:
self.en_axes[i].yaxis.set_major_formatter(NullFormatter())
###
self.t_fig = []
self.t_axes = []
for i in range(0, 12):
self.t_fig.append(Figure(figsize=(1, 1), dpi=80, frameon=False))
self.t_axes.append(self.t_fig[i].add_subplot(111))
title_text = self.create_t_title(i)
if (i == 0) or (i == 1):
self.t_fig[i].suptitle(title_text, x=0.45, y=0.95)
else:
self.t_fig[i].suptitle(title_text, x=0.3, y=0.95)
###adjust subplots to specific size
if i == 0:
self.t_fig[i].subplots_adjust(left=0.2,
bottom=0.05,
right=0.99,
top=0.99)
elif i == 1:
self.t_fig[i].subplots_adjust(left=0.2,
bottom=0.05,
right=0.99,
top=0.99)
elif i in [2, 4, 6, 8, 10]:
self.t_fig[i].subplots_adjust(left=0.05,
bottom=0.05,
right=0.99,
top=0.99)
else:
self.t_fig[i].subplots_adjust(left=0.05,
bottom=0.05,
right=0.99,
top=0.99)
###
###xlim ylim
self.t_axes[i].set_xlim(0, const.HIST_SIZE)
self.t_axes[i].set_ylim(bottom=-1)
###
###x, y ticks
self.t_axes[i].set_xticks([0, 1000, 2000, 3000, 4000])
self.t_axes[i].minorticks_on()
#self.t_axes[i].xaxis.set_major_formatter( FuncFormatter(lambda x, pos: "{:.0f}k".format(x/1e3)) )
if (i == 0) or (i == 1):
self.t_axes[i].yaxis.set_major_formatter(
FuncFormatter(format_yticks))
else:
self.t_axes[i].yaxis.set_major_formatter(NullFormatter())
###
def attach_Figs(self, grid):
for i in range(4):
en_d_vbox_name = "en_d{:d}_vbox".format(i)
en_d_vbox = self.builder.get_object(en_d_vbox_name)
en_d_vbox.pack_start(FigureCanvas(self.en_fig[i]), True, True, 0)
col, row = 0, 1
for i in range(6):
grid.attach(FigureCanvas(self.t_fig[2 * i]), col, row, 1, 1)
col += 1
col, row = 0, 2
for i in range(6):
grid.attach(FigureCanvas(self.t_fig[2 * i + 1]), col, row, 1, 1)
col += 1
def fill_Figs(self, histo):
histo_np_arr = np.array(histo)
max_histo_en = histo_np_arr[0:const.DET_NUM].max() or 1
max_histo_t = histo_np_arr[const.DET_NUM:].max() or 1
self.en_axes_line = [0] * const.DET_NUM
self.t_axes_line = [0] * 12
for i in range(0, const.DET_NUM):
x_data = np.arange(const.HIST_SIZE)
y_data = histo_np_arr[i]
self.en_axes_line[i], = self.en_axes[i].plot(x_data,
y_data,
color="blue")
self.en_axes[i].set_ylim(top=max_histo_en)
for i in range(0, 12):
x_data = np.arange(const.HIST_SIZE)
y_data = histo_np_arr[const.DET_NUM + i]
self.t_axes_line[i], = self.t_axes[i].plot(x_data,
y_data,
color="red")
self.t_axes[i].set_ylim(top=max_histo_t)
def update_Figs(self, histo):
histo_np_arr = np.array(histo)
max_histo_en = histo_np_arr[0:const.DET_NUM].max() or 1
max_histo_t = histo_np_arr[const.DET_NUM:, 1:].max() or 1
###for test
t = time()
###
print("max_histo_en = {}".format(max_histo_en))
for i in range(0, const.DET_NUM):
self.en_axes[i].set_ylim(bottom=-1, top=max_histo_en + 1)
self.en_axes_line[i].set_ydata(histo_np_arr[i])
self.en_fig[i].canvas.draw()
for i in range(0, 12):
self.t_axes[i].set_ylim(bottom=-1, top=max_histo_t + 1)
self.t_axes_line[i].set_ydata(histo_np_arr[const.DET_NUM + i])
self.t_fig[i].canvas.draw()
text = "{} {}".format(
self.create_t_title(i),
np.sum(histo_np_arr[const.DET_NUM + i][1:]))
if (i == 0) or (i == 1):
self.t_fig[i].suptitle(text, x=0.55, y=0.95)
else:
self.t_fig[i].suptitle(text, x=0.4, y=0.95)
print("plotting time = {}".format(time() - t))
def update_counts(self, det_counts):
all_zero_counts = 0
for i in range(0, const.DET_NUM):
if det_counts[i] == 0:
all_zero_counts += 1
text = "D{:d} ".format(i + 1)
if det_counts[i] < 1e3:
text += "{:.0f}".format(det_counts[i])
else:
text += "{:.2f}K".format(det_counts[i] / 1e3)
#text = "D{:d} {:.2f}K".format(i + 1, det_counts[i]/1e3)
if i == 0:
self.en_fig[i].suptitle(text, x=0.45, y=0.95)
else:
self.en_fig[i].suptitle(text, x=0.3, y=0.95)
for i in range(0, const.DET_NUM):
self.en_fig[i].canvas.draw()
def on_open(self, *args):
print("open histo")
fcd = Gtk.FileChooserDialog("Open", None, Gtk.FileChooserAction.SELECT_FOLDER, \
("Cancel", Gtk.ResponseType.CANCEL, "Open", Gtk.ResponseType.OK))
fcd.set_current_folder(self.curr_histo_folder)
response = fcd.run()
if response == Gtk.ResponseType.OK:
self.curr_histo_folder = fcd.get_current_folder()
self.spectra = Spectra(self.curr_histo_folder)
self.update_Figs(self.spectra.histo)
fcd.destroy()
elif response == Gtk.ResponseType.CANCEL:
fcd.destroy()
def on_quit(self, *args):
Gtk.main_quit(*args)
def run_fpga(self, *args):
print("Run fpga app")
self.fpga = FPGA()
self.fpga.win.show_all()
def run_histopac(self, *args):
self.logger.info("Run histopac")
histopac_exe = path.join(const.HISTOPAC_PROG_FOLDER,
const.HISTOPAC_PROG_NAME)
from os import chdir
chdir(const.HISTOPAC_PROG_FOLDER)
system("{:s} {:s}".format(histopac_exe, self.curr_histo_folder))
def run_anizpac(self, *args):
self.logger.info("Run anizpac")
#Chdir to anizpac
#call anizpac
def run_pypac_signal(self, *args):
self.logger.info("Run pypac signal app")
file_list = os.listdir(self.curr_histo_folder)
signal_file = None
for name in file_list:
try:
if name.split('.')[1] == "sgnl":
if self.curr_histo_folder[-1] == '/':
signal_file = self.curr_histo_folder + name
else:
signal_file = self.curr_histo_folder + '/' + name
break
except IndexError:
None
if signal_file is not None:
pypac_exe = path.join(const.PYPAC_PROG_FOLDER,
const.PYPAC_PROG_NAME)
system("{:s} -i {:s}".format(pypac_exe, signal_file))
else:
text = "There are no signal files in current histo folder: {:s}".format(
self.curr_histo_folder)
self.statusbar_push("error", err_msg=text)
print("!Error: " + text)
def run_pypac_histo(self, *args):
print("Run pypac histo app")
'''
if "fpga" not in self.__dict__:
print("Run FPGA should be started first")
self.fpga = FPGA()
'''
system("{:s} -h {:s}".format(
const.PYPAC_PROG_FOLDER + const.PYPAC_PROG_NAME,
self.curr_histo_folder))
def edit_config(self, *args):
system("{:s} {:s}".format(const.TXT_EDITOR,
const.MAIN_PROG_FOLDER + const.CFG_FILE))
def edit_constants(self, *args):
system("{:s} {:s}".format(
const.TXT_EDITOR, const.MAIN_PROG_FOLDER + const.CONSTANTS_FILE))
def on_start(self, *args):
btn = args[0]
if "fpga" not in self.__dict__:
print("Run FPGA should be started first")
self.fpga = FPGA()
print("On start | print acq_time = {}".format(self.fpga.acq_time))
self.fpga.save_consts_cfg(self.fpga.histo_folder)
###should be moved to separate func
info = {
"name": self.fpga.histo_folder,
"start": localtime(),
"expos": self.fpga.acq_time,
"time": 1,
"intens": 0,
}
self.information.update(info)
###
self.curr_histo_folder = self.fpga.histo_folder
print("signal flag = {}".format(self.fpga.with_signals_flag))
if self.fpga.with_signals_flag:
prog_name = const.HDRAINER_EXE + "(with signals)"
else:
prog_name = const.HDRAINER_EXE
self.hdrainer = Hdrainer(prog_name, self.fpga.acq_time,
self.fpga.coinc, self.fpga.en_range,
self.fpga.histo_folder)
self.thread_args = {"ret": -1}
t1 = Thread(target=self.hdrainer.start)
t1.start()
self.online_flag = 1
GLib.timeout_add_seconds(const.SLEEP_S_FIG_UPDATE,
self.read_plot_online_histo,
self.fpga.histo_folder)
GLib.timeout_add_seconds(const.SLEEP_S_COUNTS_UPDATE,
self.update_counts_online_histo)
self.glib_loop = GLib.MainLoop()
self.glib_loop.run()
#self.glib_loop.quit()
t1.join()
ret = self.hdrainer.ret
if (ret != 0 or ret is None):
text = prog_name + " error! Return code {}.".format(ret)
self.statusbar_push("error", err_msg=text)
else:
text = "Success execution of {} | execution_time = {:d}".format(
prog_name, self.fpga.acq_time)
self.statusbar_push("ok", normal_msg=text)
print(text)
info["time"] = 0
info["intens"] = 0
self.information.update(info)
self.hdrainer.det_counts = [0] * 4
self.update_counts(self.hdrainer.det_counts)
btn.handler_block_by_func(self.on_start)
btn.set_active(False)
btn.handler_unblock_by_func(self.on_start)
def on_stop(self, *args):
print("On stop")
self.hdrainer.stop()
def on_save(self, *args):
self.logger.info("On save")
fcd = Gtk.FileChooserDialog(title="Save", parent=None, \
action=Gtk.FileChooserAction.SELECT_FOLDER)
fcd.add_buttons("Cancel", Gtk.ResponseType.CANCEL, "Save",
Gtk.ResponseType.OK)
fcd.set_current_folder(self.curr_histo_folder)
response = fcd.run()
if response == Gtk.ResponseType.OK:
self.curr_histo_folder = fcd.get_current_folder()
self.spectra.savebin_histo_files(self.curr_histo_folder)
fcd.destroy()
elif response == Gtk.ResponseType.CANCEL:
fcd.destroy()
else:
print(type(response), response)
def on_pause(self, *args):
print("On pause")
def on_clear(self, *args):
print("On clear")
def z_en_shrink(self, *args):
print("z_en_shrink")
self.zoom.en_x_shrink()
def z_en_squeeze(self, *args):
print("z_en_squeeze")
self.zoom.en_x_squeeze()
def z_en_mov_l(self, *args):
print("z_en_mov_l")
self.zoom.en_x_move_l()
def z_en_mov_r(self, *args):
print("z_en_mov_r")
self.zoom.en_x_move_r()
def z_en_up(self, *args):
print("z_en_up")
self.zoom.en_y_up()
def z_en_down(self, *args):
print("z_en_down")
self.zoom.en_y_down()
def z_en_log(self, *args):
print("z_en_log")
self.zoom.en_log()
btn = args[0]
if btn.get_label() == "log":
btn.set_label("lin")
else:
btn.set_label("log")
def z_en_zero(self, *args):
print("z_en_zero")
self.zoom.en_zero()
def z_t_shrink(self, *args):
print("z_t_shrink")
self.zoom.t_x_shrink()
def z_t_squeeze(self, *args):
print("z_t_squeeze")
self.zoom.t_x_squeeze()
def z_t_left(self, *args):
self.zoom.t_x_move_l()
def z_t_right(self, *args):
self.zoom.t_x_move_r()
def z_t_up(self, *args):
self.zoom.t_y_up()
def z_t_down(self, *args):
self.zoom.t_y_down()
def z_t_log(self, *args):
print("z_t_log")
self.zoom.t_log()
btn = args[0]
if btn.get_label() == "log":
btn.set_label("lin")
else:
btn.set_label("log")
def read_plot_online_histo(self, hdir):
#now readbin_histo each 1 sec!!!
#update_counts should be each 1 sec only
#histo read should be 1 time ~100 sec
histo = self.spectra.readbin_histo_files(hdir)
self.update_Figs(histo)
if self.hdrainer.online:
res = True
else:
self.glib_loop.quit()
res = False
return res
def update_counts_online_histo(self):
#Update EN and T spk counts (top on the fig)
self.update_counts(self.hdrainer.det_counts)
info = {
"time": self.hdrainer.exec_time,
"intens": self.hdrainer.cycles_per_time,
}
self.information.update(info)
if self.hdrainer.online:
res = True
else:
self.glib_loop.quit()
res = False
return res
def is_glib_alive(self, x):
print("main loop is alive? {}".format(self.glib_loop.is_running()))
def statusbar_push(self, context, normal_msg="", err_msg=""):
context_id = self.statusbar.get_context_id(context)
if err_msg:
msg = "!Error!: " + err_msg
else:
msg = normal_msg
self.statusbar.push(context_id, msg)
class Mas:
mysheet = {}
def __init__(self):
# SpreadSheet
logger.info('--- Initialize Spreadsheet')
self.mysheet = Sheet()
# Google Drive
logger.info('--- Initialize Google Drive')
self.mydrive = GDrive()
# Slack
# logger.info('--- Initialize Slack')
# self.slack = Slack()
# Zoom
logger.info('--- Initialize Zoom')
self.zoom = Zoom()
# Email
# logger.info('--- Initialize Email')
# self.email = Email()
'''
Google Spreadsheet
'''
def update_ccs_sheet(self):
self.mysheet.update_ccs_sheet_from_df(self.updated_ccs)
'''
Google Drive
'''
def drive_setup(self):
logger.info('--- Setup Google Drive')
self.mydrive.setup(self.mysheet)
self.updated_ccs = self.mydrive.generate_links_and_share_permission()
self.update_ccs_sheet()
'''
Slack
'''
def slack_setup(self):
self.updated_ccs = self.slack.setup(self.mysheet)
self.update_ccs_sheet()
'''
Zoom
'''
def zoom_setup(self):
self.updated_ccs = self.zoom.setup(self.mysheet, self.mydrive)
# self.update_ccs_sheet()
'''
Email
'''
def email_setup(self):
self.email.send_email()
def run(self):
# self.drive_setup()
self.zoom_setup()
if args['path']:
stream = cv2.VideoCapture(args['path'])
cfg['FRAME_HEIGHT'] = int(stream.get(4))
cfg['FRAME_WIDTH'] = int(stream.get(3))
else:
if args['camera'].isdigit():
stream = cv2.VideoCapture(int(args['camera']))
else:
stream = cv2.VideoCapture(args['camera'])
stream.set(cv2.CAP_PROP_FRAME_WIDTH, cfg['FRAME_WIDTH'])
stream.set(cv2.CAP_PROP_FRAME_HEIGHT, cfg['FRAME_HEIGHT'])
################################################################################
motor = Motor(dev = args['motor'], baud = 115200, screen_width = cfg['WIDTH'])
zoom = Zoom(dev = args['zoom'], baud = 115200, screen_width = cfg['WIDTH'])
redis_agent = RedisAgent(redis.Redis(), [cfg['CHANNEL_NAME']])
redis_agent.start()
################################################################################
def onmouse(event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDOWN:
param['dragging'] = True
param['x1'] = x
param['y1'] = y
param['x2'] = x
param['y2'] = y
elif event == cv2.EVENT_MOUSEMOVE:
if param['dragging'] == True:
if args['path']:
stream = cv2.VideoCapture(args['path'])
cfg['FRAME_HEIGHT'] = int(stream.get(4))
cfg['FRAME_WIDTH'] = int(stream.get(3))
else:
if args['camera'].isdigit():
stream = cv2.VideoCapture(int(args['camera']))
else:
stream = cv2.VideoCapture(args['camera'])
stream.set(cv2.CAP_PROP_FRAME_WIDTH, cfg['FRAME_WIDTH'])
stream.set(cv2.CAP_PROP_FRAME_HEIGHT, cfg['FRAME_HEIGHT'])
################################################################################
motor = Motor(dev=args['motor'], baud=115200, screen_width=cfg['WIDTH'])
zoom = Zoom(dev=args['zoom'], baud=115200, screen_width=cfg['WIDTH'])
redis_agent = RedisAgent(redis.Redis(), [cfg['CHANNEL_NAME']])
redis_agent.start()
################################################################################
def onmouse(event, x, y, flags, param):
if event == cv2.EVENT_LBUTTONDOWN:
param['dragging'] = True
param['x1'] = x
param['y1'] = y
param['x2'] = x
param['y2'] = y
elif event == cv2.EVENT_MOUSEMOVE:
#!############################ Init I/O #########################
if (os.path.isfile('./logs.xlsx')):
wb = load_workbook(filename='logs.xlsx')
ws = wb.active
else:
newWorkbook()
#port = portusb.lstPort()
port = portusb.portNew()
print('[INFO] Openning ' + port)
ser = serial.Serial(port, 9600)
vs3 = Zoom(400, cameraindex.index('Camera'), 169, 266, 189, 377).start()
vs4 = Zoom(400, cameraindex.index('CAMERA'), 263, 372, 179, 438).start()
sleep(2.0)
fps = FPS().start()
#!############################ Loop #########################
while True:
try:
serInWait = ser.in_waiting
except OSError:
vs3.stop()
vs4.stop()
ser.close()