async def test_file_upload():
NUM_PEERS = 10
conn_matrix = np.zeros((NUM_PEERS, NUM_PEERS))
np.fill_diagonal(conn_matrix[:, 1:], 1)
np.fill_diagonal(conn_matrix[1:, :], 1)
s = Setup(PEERSTER_ROOT, NUM_PEERS, conn_matrix, anti_entropy=2)
s.run_all()
await asyncio.sleep(.5)
# Upload files
files = []
for i, peerster in enumerate(s.peersters):
with open(f"{peerster.root}/_SharedFiles/test{i}.txt", "w+") as f:
to_file = "12345678" * 1000 + peerster.name + "12345678" * 1000
files.append(to_file)
f.write(to_file)
peerster.upload_file(f"test{i}.txt")
await asyncio.sleep(.5)
await s.stop_all()
# Assert files are uploaded
for i, peerster in enumerate(s.peersters):
with open(f"{peerster.root}/_SharedFiles/test{i}.txt", "rb") as f:
h = Tests._calc_hash(f)
assert h in peerster.uploaded_files
def __init__(self, test_utility, model, serial_manager, report):
super().__init__()
self.abort_btn = QPushButton("Abort")
self.abort_btn.clicked.connect(self.abort)
self.setButton(QWizard.CustomButton1, self.abort_btn)
self.button(QWizard.FinishButton).clicked.connect(self.finish)
qbtn_layout = [
QWizard.Stretch, QWizard.NextButton, QWizard.FinishButton,
QWizard.CustomButton1
]
self.setButtonLayout(qbtn_layout)
self.button(QWizard.NextButton).setEnabled(False)
# This fixes a bug in the default style which hides the QWizard
# buttons until the window is resized.
self.setWizardStyle(0)
setup_id = self.addPage(
Setup(self, test_utility, serial_manager, model, report))
program_id = self.addPage(
Program(self, test_utility, serial_manager, model, report))
interfaces_id = self.addPage(
Interfaces(self, test_utility, serial_manager, model, report))
final_id = self.addPage(FinalPage(self, test_utility, report))
self.setup_page = self.page(setup_id)
self.program_page = self.page(program_id)
self.interfaces_page = self.page(interfaces_id)
self.final_page = self.page(final_id)
self.tu = test_utility
self.report = report
async def test_public_messages():
NUM_PEERS = 50
conn_matrix = np.zeros((NUM_PEERS, NUM_PEERS))
np.fill_diagonal(conn_matrix[:, 1:], 1)
np.fill_diagonal(conn_matrix[1:, :], 1)
print(conn_matrix)
s = Setup(PEERSTER_ROOT, NUM_PEERS, conn_matrix, anti_entropy=2)
s.run_all()
await asyncio.sleep(1)
for i, peerster in enumerate(s.peersters):
peerster.send_public_message(f"Test{i}")
await asyncio.sleep(10)
await s.stop_all()
for i, peerster in enumerate(s.peersters):
print(peerster.public_messages)
for j, other_peerster in enumerate(s.peersters):
if i == j:
continue
assert peerster.public_messages[f"testPeer{j}"] == {1: f"Test{j}"}
def new_students(self):
"""Checks data for new students."""
print('Checking for new students...')
# Creates list of existing students.
existing_students = []
with open('storage.csv', 'r') as storage:
reader = csv.reader(storage)
for row in reader:
existing_students.append(row[0])
def mask(email):
if email in existing_students:
return False
return True
# Reduces student_data DataFrame to new students only.
new_data = self.student_data[self.student_data['Student Email'].apply(
mask)]
new_students = Data(df=new_data)
if len(new_students.student_data) > 0:
print('New students found.')
print(new_students.student_data)
Setup(new_students)
else:
print('No new students found.')
def get_pass():
password_feild.delete(0, END)
if (length_feild.get() == ''):
messagebox.showerror(
"No value Entered", "Please Fill the Entry Feilds"
) # This is to make a default password, this must be changed
else:
try:
tem_len = int(length_feild.get())
tem_spe = int(special_feild.get())
tem_dig = int(digit_feild.get())
except ValueError as e:
messagebox.showerror("Input Error", "Please enter an Number")
else:
data = ((tem_len - (tem_dig + tem_spe), tem_dig, tem_spe)
) # Doing the calculation and porcessing
length_feild.delete(0, END)
digit_feild.delete(0, END)
special_feild.delete(0, END)
generate = Setup(
data
) # This is from the Class Setup which is imported and an instance is created
pass_word = generate.get_password() # Calling the method
password_feild.insert(0, pass_word)
pyperclip.copy(
pass_word
) # This is for copying the password directly into the clipboard
copied_status = Label(
root,
text="The password is copied to the clipboard",
bg="yellow",
fg="black")
copied_status.grid(row=5)
def on_service_state_change(zeroconf, service_type, name, state_change):
logger.info("Service %s of type %s state changed: %s" % (name, service_type, state_change))
logger.info("State change: %s" % state_change)
if state_change is ServiceStateChange.Added:
info = zeroconf.get_service_info(service_type, name)
if info:
logger.info(" Address: %s:%d" % (socket.inet_ntoa(info.address), info.port))
logger.info(" Weight: %d, priority: %d" % (info.weight, info.priority))
logger.info(" Server: %s" % (info.server,))
ip = ("%s:%d" % (socket.inet_ntoa(info.address), info.port))
device = Setup(name, ip)
device.register()
if info.properties:
logger.info(" Properties are:")
for key, value in info.properties.items():
logger.info(" %s: %s" % (key, value))
else:
logger.info(" No properties")
else:
logger.info(" No info")
logger.info('\n')
elif state_change is ServiceStateChange.Removed:
logger.info("Removing %s" % (name))
def collect_relevant_files(self):
self.storage = EDF_Store(files_with_categs={},
filenames=[],
categ_names=[])
self.storage.fetch_data()
self.eeg_setup = Setup(params=self.storage.test_user_ids)
self.eeg_setup.run()
def run( self, u_info ):
# self, mojo_dir, tmp_dir, /// out_dir, dojoserver
# register two data sources
self.__segmentation = Segmentation( u_info.files_path , u_info.tmpdir, self)
self.__image = Image( u_info.files_path , u_info.tmpdir)
# and the controller
self.__controller = Controller( u_info, self.__segmentation.get_database(), self ) ####
# and the viewer
self.__viewer = Viewer()
# and the controller
if self.__segmentation:
db = self.__segmentation.get_database()
else:
db = None
self.__controller = Controller( u_info, db, self )
# and the setup
self.__setup = Setup(self, u_info.files_path, u_info.tmpdir)
print('path_gfx: ',path_gfx)
# running live
####
asyncio.set_event_loop(u_info.worker_loop)
dojo = tornado.web.Application([
(r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': path_gfx}),
(r'/ws', Websockets, dict(controller=self.__controller)),
(r'/(.*)', DojoHandler, dict(logic=self))
],debug=True,autoreload=True) # (r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': '/dojo/gfx'})
# dojo.listen(u_info.port, max_buffer_size=1024*1024*150000)
server = tornado.httpserver.HTTPServer(dojo)
server.listen(u_info.port)
print('*'*80)
print('*', 'DOJO RUNNING')
print('*')
print('*', 'open', '[ http://' + u_info.ip + ':' + str(u_info.port) + '/dojo/ ] ')
print('*'*80)
tornado.ioloop.IOLoop.instance().start()
server.stop()
# def sig_handler(signum, frame):
# IOLoop.current().add_callback_from_signal(receiver.shutdown)
print("Tornado web server stops.")
return
def set_setup(self, qualifying):
weather = self.get_weather(qualifying)
temp = self.get_temp(qualifying)
if qualifying == 'Q2' or 'Race':
weather_select_element = browser.find_element_by_name('weatherr')
weather_select = Select(weather_select_element)
new_weather = weather
if weather == 'Rain':
new_weather = 'Wet'
weather_select.select_by_visible_text(new_weather)
weather_input_element = browser.find_element_by_name('tempr')
weather_input_element.clear()
weather_input_element.send_keys(temp)
btn_recalc_element = browser.find_element_by_class_name('SubmitButton')
btn_recalc_element.click()
setup_elements = browser.find_elements_by_xpath('//th[@class="Calc Blue"]/input')
setup = Setup()
setup.original_front_wing = setup_elements[0].get_attribute('value')
setup.original_rear_wing = setup_elements[1].get_attribute('value')
setup.engine = setup_elements[2].get_attribute('value')
setup.brakes = setup_elements[3].get_attribute('value')
setup.gear = setup_elements[4].get_attribute('value')
setup.suspension = setup_elements[5].get_attribute('value')
setup.qualifying = qualifying
setup.temperature = temp
setup.weather = weather
return setup
def __init__(self):
self.settings = Settings()
self.logger = Logger(self.settings.logfile)
self.reporter = Reporter(self.settings)
self.setup = Setup(self.settings, self.logger)
self.grader = Grader(self.settings, self.logger, self.setup)
self.analyser = Analyser(self.settings, self.reporter, self.logger,
self.setup, self.grader)
def __init__(self, cfg, label):
self.cfg = cfg
self.cfg.check_parametersSet()
self.cfg.log_parametersSet(label)
self.setup = Setup(cfg.parametersSet)
self.trees = self.setup.grow_trees()
self.setup.create_observable()
self.init_selection()
def add_relevant_files_to_database(self):
self.eeg_setup = Setup(params=None)
self.eeg_setup.run()
self.process_files()
self.storage = EDF_Store(self.eeg_setup.files_with_categs,
self.eeg_setup.filenames,
self.eeg_setup.categ_names)
self.storage.record_data()
def main():
if arg.signals_mit:
try:
gs = GetSignals()
gs.mit(mit)
except Exception as e:
print(e)
elif arg.signals_ecgid:
try:
gs = GetSignals()
gs.mit(ecgid)
except Exception as e:
print(e)
elif arg.signals_bmd:
try:
gs = GetSignals()
gs.mit(bmd101)
except Exception as e:
print(e)
elif arg.features_mit:
try:
feats = GetFeatures()
feats.features('mit', mit)
except Exception as e:
print(e)
elif arg.features_ecgid:
try:
feats = GetFeatures()
feats.features('ecgid', mit)
except Exception as e:
print(e)
elif arg.features_bmd:
try:
feats = GetFeatures()
feats.features('bmd', mit)
except Exception as e:
print(e)
elif arg.setup:
try:
su = Setup()
su.load_signals(2500, "cnn", mit[:40], 0)
su.load_signals(2500, "snn", mit[:40], 0)
except Exception as e:
print(e)
elif arg.snn:
try:
snn.main()
except Exception as e:
print(e)
elif arg.cnn:
try:
cnn.main()
except Exception as e:
print(e)
def start():
puzzle = Sudoku()
setup = Setup(puzzle)
setup.runSetup()
print("Setup done, solving...")
puzzleSolver = Solver(puzzle)
solved, iterations = puzzleSolver.solve()
puzzle.print()
print("Solved:", solved, iterations, "iterations")
def __init__(self, **kwagrs):
self.setup = Setup(**kwagrs)
self.t0 = dt()
s = self.setup
self.T = self.setup.T
self.v_couple_shape = [(s.na_c, s.nexo_t[t], s.ntheta_coarse)
for t in range(self.T)]
self.v_sf_shape = [(s.na_s, s.n_zf) for t in range(self.T)]
self.v_sm_shape = [(s.na_s, s.n_zm) for t in range(self.T)]
print('setup created, time {}'.format(dt() - self.t0))
self.solve()
def __init__(self, uplink, config, session_id, hydra_url):
'''
Constructor
'''
self.uplink = uplink
self.config = config
self.session_id = session_id
self.hydra_url = hydra_url
self.setup = Setup(self)
if self.config.has_option('general', 'fake'):
self.fake = (self.config.get('general', 'fake') == "yes")
else:
self.fake = False
def __init__(self, ipAddr=None, port=80):
# Init Midi client and display available devices
midiINPort = mido.get_input_names()[0]
midiOUTPort = mido.get_output_names()[0]
self.midiIN = mido.open_input(midiINPort)
self.midiOUT = mido.open_output(midiOUTPort)
self.mcu = MCU()
self.motu = Motu(ipAddr, port)
self.settings = Settings()
self.hwSetup = Setup()
self.mixerUrl = "http://{}:{}".format(ipAddr, port)
print("Will send events to mixer at {}".format(self.mixerUrl))
self.recall()
def __init__(self, label, params={}, **kwargs):
self.label = label
self.setup = Setup()
self.ana = Analytics()
if 'analysis_type' in kwargs:
self.analysis_type = kwargs['analysis_type']
else:
self.analysis_type = 'dynamical'
# set default analysis and circuit parameter
self._set_up_circuit(params, kwargs)
# set parameter derived from analysis and circuit parameter
new_vars = self.setup.get_params_for_analysis(self)
new_vars['label'] = self.label
self._set_class_variables(new_vars)
# set variables which require calculation in analytics class
self._calc_variables()
async def test_file_download():
NUM_PEERS = 10
conn_matrix = np.zeros((NUM_PEERS, NUM_PEERS))
np.fill_diagonal(conn_matrix[:, 1:], 1)
np.fill_diagonal(conn_matrix[1:, :], 1)
s = Setup(PEERSTER_ROOT, NUM_PEERS, conn_matrix, anti_entropy=2)
s.run_all()
await asyncio.sleep(.5)
# Send route rumors
for i, peerster in enumerate(s.peersters):
peerster.send_public_message(f" ")
# Upload files
files = []
for i, peerster in enumerate(s.peersters):
with open(f"{peerster.root}/_SharedFiles/test{i}.txt", "w+") as f:
to_file = "12345678" * 1000 + peerster.name + "12345678" * 1000
files.append(to_file)
f.write(to_file)
peerster.upload_file(f"test{i}.txt")
await asyncio.sleep(.5)
# Don't calculate hash ourselves, but use peerster hashes: test doesn't fail
# if hashing/chunking is done incorrectly
metas = []
for i, peerster in enumerate(s.peersters):
assert len(peerster.uploaded_files) == 1
hash = next(iter(peerster.uploaded_files))
assert len(hash) == 64
metas.append(hash)
await asyncio.sleep(2)
for i, peerster in enumerate(s.peersters):
other = (i - 7) % len(s.peersters)
peerster.download_file(f"test{other}_d.txt", metas[other], f"testPeer{other}")
await asyncio.sleep(10)
for i, peerster in enumerate(s.peersters):
assert f"test{(i-7)%len(s.peersters)}_d.txt" in peerster.downloaded_files
await s.stop_all()
def appRun():
s = Setup()
if s.load():
s.showSelf()
else:
s.consInit()
s.save()
frames = JsonFileToFrames(s.inputFile)
print('Frames count = ' + str(len(frames)))
printer = BlenderPrinter(len(frames), s.outputDir, s.FPS)
iter = 0
for frame in frames:
printer.printFrame(frame, iter + 1)
iter += 1
def move():
# tic = time.time()
data = request.get_json()
#NOTE grid_data[0] = move_grid // grid_data[1] = food_grid
setup_process = Setup()
helper = Helper()
grid_data = setup_process.grid_setup(data)
# Game States
defend = State_Defend()
attack = State_Attack()
grow = State_Grow()
# Assign the global helper methods to each state
defend.helper = helper
attack.helper = helper
grow.helper = helper
max_snake = helper.get_max_snake_length(data)
closest_food_distance = helper.get_closest_food_dist(grid_data[1], data)
board_width = data.get("board").get("width")
if len(data.get("you").get("body")) > max_snake + 1:
# Assign the attack state when we are 2 bigger than any other snake
state = attack
elif closest_food_distance < board_width / 1.5:
# Assign the grow state if a piece of food is within boardlen/1.5
# or if there are more than 5 pieces of food on the board
state = grow
else:
state = defend
#NOTE Get the next move based on the pellet
next_move = state.get_move(grid_data, data)
# toc = time.time()
# print("Move for round: {}".format(data.get("turn")))
# print("Time used: {}ms".format((toc - tic)*1000))
# print("State: {}".format(state.name))
#helper.print_board(grid_data[0])
#NOTE Return the move in the JSON object wrapper
return jsonify(move=next_move)
def start_game(self):
"""
Hides main menu window and displays the board setup window
"""
# hide the menu window, and the rules window if it is open
self.root.withdraw()
if self.rules_displayed:
self.rules_window.withdraw()
def show_callback():
# after game finishes (by either loss or win), display the windows again
self.root.deiconify()
if self.rules_displayed:
self.rules_window.deiconify()
# create board setup window
self.setup = Setup(self.root, show_callback)
def test_setup_load_properties(mock_logIt):
obj = Setup()
assert_equal(obj.installOxAuth, True)
assert_equal(obj.installOxTrust, True)
assert_equal(obj.installLdap, True)
assert_equal(obj.installHttpd, True)
assert_equal(obj.installSaml, False)
assert_equal(obj.installAsimba, False)
assert_equal(obj.installCas, False)
assert_equal(obj.installOxAuthRP, False)
# all false
obj.load_properties('tests/sample1.properties')
assert_equal(obj.installOxAuth, False)
assert_equal(obj.installOxTrust, False)
assert_equal(obj.installLdap, False)
assert_equal(obj.installHttpd, False)
assert_equal(obj.installSaml, False)
assert_equal(obj.installAsimba, False)
assert_equal(obj.installCas, False)
assert_equal(obj.installOxAuthRP, False)
# all true
obj.load_properties('tests/sample2.properties')
assert_equal(obj.installOxAuth, True)
assert_equal(obj.installOxTrust, True)
assert_equal(obj.installLdap, True)
assert_equal(obj.installHttpd, True)
assert_equal(obj.installSaml, True)
assert_equal(obj.installAsimba, True)
assert_equal(obj.installCas, True)
assert_equal(obj.installOxAuthRP, True)
# mix of both true and false
obj.load_properties('tests/sample3.properties')
assert_equal(obj.installOxAuth, False)
assert_equal(obj.installOxTrust, True)
assert_equal(obj.installLdap, False)
assert_equal(obj.installHttpd, True)
assert_equal(obj.installSaml, False)
assert_equal(obj.installAsimba, True)
assert_equal(obj.installCas, False)
assert_equal(obj.installOxAuthRP, True)
class MiTCPHandler(SocketServer.StreamRequestHandler):
Config = Setup()
def handle(self):
package = ""
while package != "salir":
try:
package = self.rfile.readline().strip()
#package = self.request.recv(4000)
if (package != ""):
package = loads(package)
print package
mensaje = protocolHandler(self.Config, package)
print mensaje
mensaje = dumps(mensaje)
self.request.sendall(mensaje)
except:
print "Error on package:"
print package
async def test_private_messages():
NUM_PEERS = 50
conn_matrix = np.zeros((NUM_PEERS, NUM_PEERS))
np.fill_diagonal(conn_matrix[:, 1:], 1)
np.fill_diagonal(conn_matrix[1:, :], 1)
s = Setup(PEERSTER_ROOT, NUM_PEERS, conn_matrix, anti_entropy=1)
s.run_all()
await asyncio.sleep(1)
for peerster in s.peersters:
peerster.send_public_message(f" ")
await asyncio.sleep(10)
msg_map = {}
for i, peerster in enumerate(s.peersters):
if i - 7 < 0 and not i + 7 >= len(s.peersters):
other = i + 7
else:
other = i - 7
msg_map[other] = msg_map.get(other, []) + [i]
peerster.send_private_message(f"Test{i}",
f"testPeer{other}")
await asyncio.sleep(30)
await s.stop_all()
for i, peerster in enumerate(s.peersters):
others = msg_map.get(i)
if others is None:
continue
for other in others:
peer = f"testPeer{other}"
assert peer in peerster.private_messages.keys()
assert len(peerster.private_messages[peer]) == 1
assert peerster.private_messages[peer][0] == {"msg": f"Test{other}", "hop-lim": "3"}
def main():
"""Setup and run the backup."""
awsargs = {
'region': 'eu-west-1',
'endpoint': 'http://192.168.99.100:4569',
'key': 'localstack',
'secret': 'localstack'
}
args = _parse_cli_args()
level = logging.DEBUG if args.verbose else logging.INFO
if args.verbose:
for logger in {
'boto3', 'botocore', 'requests',
'botocore.vendored.requests.packages.urllib3.connectionpool'
}:
logging.getLogger(logger).setLevel(level)
LOGGER.error('STARTTINGG')
LOGGER.info('Sleeping for 5 seconds')
time.sleep(5)
LOGGER.info('Woke up')
setup = Setup()
setup.setup()
_execute(args, awsargs)
import numpy
from Parser import DataPreparer
from CustomConsoleInterface import CustomConsoleInterface
from Analyzer import Analyzer
from Classifier import KMeansClassifier, Forest
from Visualizer import Visualizer
from setup import Setup
import logging
logging.basicConfig(filename='debug/debug.log', level=logging.DEBUG)
setup = Setup()
interface = CustomConsoleInterface()
vis = Visualizer()
dp = DataPreparer('sources/dataset.xlsx')
analyzer = Analyzer()
dp.parse()
additional_info = True
pairplot_flag = True
test_flag = False
separate_flag = True
dp.remove_useless(*interface.make_checkbox([{
'name': i
} for i in dp.get_dataset_no_useless.keys()], 'choose useless',
'useless_columns').values())
if additional_info:
dp.gender_changes(*interface.make_list([{
# Please place this script in the same directory as setup.py
import os
import ldap
import xml.etree.ElementTree as ET
import shutil
import glob
from setup import Setup
from pylib.cbm import CBM
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_ALLOW)
scripts_location = 'ldap'
setupObject = Setup(os.path.dirname(os.path.realpath(__file__)))
setupObject.os_initdaemon = setupObject.detect_initd()
setupObject.os_type, setupObject.os_version = setupObject.detect_os_type()
if os.path.exists(setupObject.gluu_hybrid_roperties):
for l in open(setupObject.gluu_hybrid_roperties):
ls = l.strip()
if ls.startswith('storage.default'):
n = ls.find(':')
scripts_location = ls[n + 1:].strip()
elif os.path.exists(setupObject.gluuCouchebaseProperties):
scripts_location = 'couchbase'
identtiy_xml_fn = '/opt/gluu/jetty/identity/webapps/identity.xml'
tree = ET.parse(identtiy_xml_fn)
parser = argparse.ArgumentParser()
parser.add_argument("-addshib",
help="Install Shibboleth SAML IDP",
action="store_true")
parser.add_argument("-addpassport",
help="Install Passport",
action="store_true")
args = parser.parse_args()
if len(sys.argv) < 2:
parser.print_help()
parser.exit(1)
from setup import Setup
setupObj = Setup('.')
setupObj.setup = setupObj
setupObj.load_properties(
'/install/community-edition-setup/setup.properties.last')
if setupObj.ldap_type == 'opendj':
setupObj.ldapCertFn = setupObj.opendj_cert_fn
else:
setupObj.ldapCertFn = setupObj.openldapTLSCert
setupObj.ldapCertFn = setupObj.opendj_cert_fn
def installSaml():
def __init__(self):
# No communications or arming yet
self.comms = None
self.armed = False
# Do basic Tk initialization
self.root = Tk()
self.root.configure(bg=BACKGROUND_COLOR)
self.root.resizable(False, False)
self.root.title('Hackflight Ground Control Station')
left = (self.root.winfo_screenwidth() - DISPLAY_WIDTH) / 2
top = (self.root.winfo_screenheight() - DISPLAY_HEIGHT) / 2
self.root.geometry('%dx%d+%d+%d' % (DISPLAY_WIDTH, DISPLAY_HEIGHT, left, top))
self.frame = Frame(self.root)
self.root.wm_iconbitmap(bitmap = "@media/icon.xbm")
self.root.tk.call('wm', 'iconphoto', self.root._w, PhotoImage('icon.png'))
self.root.protocol('WM_DELETE_WINDOW', self.quit)
# Create panes for two rows of widgets
self.pane1 = self._add_pane()
self.pane2 = self._add_pane()
# Add a buttons
self.button_connect = self._add_button('Connect', self.pane1, self._connect_callback)
self.button_setup = self._add_button('Setup', self.pane2, self._setup_callback)
self.button_motors = self._add_button('Motors', self.pane2, self._motors_button_callback)
self.button_receiver = self._add_button('Receiver', self.pane2, self._receiver_button_callback)
self.button_messages = self._add_button('Messages', self.pane2, self._messages_button_callback)
#self.button_maps = self._add_button('Maps', self.pane2, self._maps_button_callback, disabled=False)
# Prepare for adding ports as they are detected by our timer task
self.portsvar = StringVar(self.root)
self.portsmenu = None
self.connected = False
self.ports = []
# Finalize Tk stuff
self.frame.pack()
self.canvas = Canvas(self.root, width=DISPLAY_WIDTH, height=DISPLAY_HEIGHT, background='black')
self.canvas.pack()
# Add widgets for motor-testing dialog; hide them immediately
self.motors = Motors(self)
self.motors.stop()
# Create receiver dialog
self.receiver = Receiver(self)
# Create messages dialog
self.messages = Messages(self)
# Create setup dialog
self.setup = Setup(self)
self._schedule_connection_task()
# Create a maps dialog
#self.maps = Maps(self, yoffset=-30)
# Create a splash image
self.splashimage = PhotoImage(file='media/splash.png')
self._show_splash()
# Create a message parser
self.parser = MSP_Parser()
# Set up parser's request strings
self.attitude_request = self.parser.serialize_ATTITUDE_Request()
self.rc_request = self.parser.serialize_RC_Request()
# No messages yet
self.yaw_pitch_roll = 0,0,0
self.rxchannels = 0,0,0,0,0
# A hack to support display in Setup dialog
self.active_axis = 0
