def main():
root = tk.Tk()
app = gui.App(master=root)
root.title("playerEstimation")
root.geometry("580x580")
app.mainloop()
root.destroy()
def main():
global graphVar, exit, guiVar, predictioncondition
#setpriority(5)
threadHK = threading.Thread(target=housekeeper, args=())
threadHK.setDaemon(True)
threadHK.start()
threadKeys = threading.Thread(target=keys, args=())
#threadKeys.setDaemon(True)
threadKeys.start()
print("Setup finished, starting threads")
if len(sys.argv) > 1:
if sys.argv[1] == "gui":
app = ttk.App()
elif sys.argv[1] == "drone":
killkeys = True
threadDataCatcher = threading.Thread(target=dataCatcher, args=())
threadDataCatcher.setDaemon(True)
threadDataCatcher.start()
predictioncondition = True
housekeepThread = threading.Thread(target=controller.housekeeper,
args=())
housekeepThread.start()
#controller.droneController()
controller.originalDroneController()
os._exit(0)
#threadDataCatcher = threading.Thread(target=dataCatcher,args=())
#threadDataCatcher.setDaemon(True)
#threadDataCatcher.start()
#threadGui = threading.Thread(target=ttk.guiloop, args=())
#threadGui.setDaemon(True)
#threadGui.start()
#ttk.guiloop()
#thread2 = threading.Thread(target=QtGui.QApplication.instance().exec_(),args=())
#thread2.start()
#thread0.join()
#thread1.join()
#thread2.join()
#while not graphVar:
#tme.sleep(0.1)
'''
while not guiVar:
tme.sleep(0.1)
if not exit:
#graph()
#ttk.guiloop()
app = ttk.App()
'''
while not exit:
tme.sleep(1)
def main():
'''
Excutes full program. Sets up all handlers and initailzes the gui
'''
time_string = datetime.now().strftime('%Y%m%d %H%M')
# Get necessary file paths
paths = init_paths()
# paths = {'instep':'C:/Users/Raman/Desktop/Instep_out', 'raw':'C:/Users/Raman/Desktop/Raman/Input'}
raman_regex = r'.+\.txt' # Raman file is any that ends in .txt
# InStepAutosave is any that ends in InStepAutoSave.txt
instep_regex = r'.+InStepAutoSave\.txt'
# Create the raw spectrum handler
raw_handler = classes.RawFileProcessor()
# Create the plotter for the prediction handler, then create the prediction handler
prediction_plotter = classes.Plotter()
prediction_plotter.set_ylabel('Concentration (g/L)')
prediction_handler = classes.PredictionHandler(prediction_plotter)
# Create the plotter for the PID handler, then create the PID handler
pid_plotter = classes.Plotter()
pid_plotter.set_ylabel('Cumulative Vol. (mL)')
# Here the log file of the PID handler is set to be in the same directory as
# the InStep autosave file.
# Other defaults are set, like the 200mL max volume, and that it's tracking index 0 of
# the autosave file
paths['log_file'] = paths[
'instep'] + f'/pid_log_{time_string}.txt' # Where to save PID output
pid_handler = classes.PIDHandler(200, prediction_handler, pid_plotter, 0,
paths['log_file'])
# Create the plotting_dict and pass it to the App
plot_dict = {'Raman Plot': prediction_plotter, 'PID Plot': pid_plotter}
app = gui.App(plot_dict, pid_handler)
# Get the current event loop
loop = asyncio.get_event_loop()
# Add the three async tasks defined above to event loop
loop.create_task(run_tk(app, loop))
loop.create_task(raw_watcher(paths['raw'], raman_regex, raw_handler))
loop.create_task(
instep_watcher(paths['instep'], instep_regex, prediction_handler,
pid_handler, app, paths['log_file']))
# Run the loop forever
loop.run_forever()
def main():
global APP
APP = gui.App()
APP.Update()
TIMER = threading.Timer(1, Mouse_Fix)
TIMER.start()
hm = pyHook.HookManager()
hm.KeyDown = onKeyboardEvent
hm.HookKeyboard()
hm.MouseAll = onMouseEvent
hm.HookMouse()
pythoncom.PumpMessages()
def main(args):
# Imports are here so we don't need to wait for them to load unecessarily.
import os
import tkinter
from video import Video
from annotation import Annotations
from state import State
import gui
# Parameters
video_file_path = args.video_file_path
annotation_file_path = args.annotation_file_path
if annotation_file_path is None:
# Expect the following dir structure:
# dataset/
# - videos/
# - annotations/
split_path = os.path.split(video_file_path)
annotation_file_name = split_path[-1].split('.')[0] + '.pkl'
annotation_file_dir = list(split_path[:-1]) + ['..', 'annotations']
annotation_file_dir = os.path.join(*annotation_file_dir)
if not os.path.isdir(annotation_file_dir):
print('Invalid directory structure.')
return
annotation_file_path = os.path.join(annotation_file_dir,
annotation_file_name)
# Load Video
video = Video(video_file_path)
annotations = Annotations(annotation_file_path, video)
state = State(video, annotations)
# Create GUI
gui.App(tkinter.Tk(), state)
# When everything done, release the video capture object
video.close()
#!/usr/bin/env python3
from tkinter import Tk
from twisted.internet import reactor, tksupport
import gui
if __name__ == '__main__':
root = Tk()
tksupport.install(root)
gui.App(root)
reactor.run()
def main():
root = gui.App()
# peer.build_peers(host, args.build_from, hops=10)
# if args.file_get:
# file_name = args.file_get
# peer.connect_and_send(host, args.peer_port, 'FGET', file_name)
# if args.query:
# file_name = args.query
# my_id = f'{host}:{port}'
# ttl = '5'
# data = ' '.join((my_id, file_name, ttl))
# print('querying')
# peer.connect_and_send(host, args.peer_port, 'QUER', data)
# if args.gui:
# gui.main_loop(host=host, port=args.port)
# if args.run:
# peer.main_loop()
if args.gui:
build_from = None
if args.build_from:
build_from = RemotePeer(host=host, port=args.build_from)
app = gui.App(host=host,
port=args.port,
build_from=build_from,
debug=args.debug)
app.mainloop()
if args.run:
peer.main_loop()
import pygame
from pygame.locals import *
import gui
screen = pygame.display.set_mode(
(640, 480), FULLSCREEN) # try adding DOUBLEBUF | HWSURFACE
# pygame.mouse.set_visible(0)
app = gui.App()
c = gui.Container(width=640, height=480)
##
## dialog 1
##
t1 = gui.Table()
t1.tr()
t1.add(gui.Label("Gal Test"))
t2 = gui.Table()
t2.tr()
t2.add(gui.Label("Gui Widgets"))
t2.add(gui.Input())
t2.tr()
t2.add(gui.Label("Button"))
t2.add(gui.Button("Click Me!"))
d1 = gui.Dialog(t1, t2)
c.add(d1, 50, 150)
def gui_connect():
# handles the connection with the gui lib
app = gui.QtWidgets.QApplication(gui.sys.argv)
ex = gui.App()
gui.sys.exit(app.exec())
def analyze_chars(char_names):
start_time = time.time()
wx.CallAfter(app.PySpy.list.DeleteAllItems)
try:
outlist = analyze.main(char_names)
duration = round(time.time() - start_time, 1)
reportstats.ReportStats(outlist, duration).start()
if outlist is not None:
wx.CallAfter(app.PySpy.updateList, outlist, duration)
else:
statusmsg.push_status(
"No valid character names found. Please try again...")
except Exception:
Logger.error("Failed to collect character information. Clipboard "
"content was: " + str(char_names),
exc_info=True)
app = gui.App(0) # Has to be defined before background thread starts.
background_thread = threading.Thread(target=watch_clpbd, daemon=True)
background_thread.start()
update_checker = threading.Thread(target=chkversion.chk_github_update,
daemon=True)
update_checker.start()
app.MainLoop()
if (d == "Amazon"):
for x in os.listdir(os.path.join(main_path, "Data", "Accounts", d)):
Amazon = parser.Amazon_Parser(
os.path.join(main_path, "Data", "Accounts", d, x, ""), KEYS)
all_accounts.append(Amazon)
all_account_names.append(x)
if (d == "DiBa"):
for x in os.listdir(os.path.join(main_path, "Data", "Accounts", d)):
DiBa = parser.DiBa_Parser(
os.path.join(main_path, "Data", "Accounts", d, x, ""), KEYS)
all_accounts.append(DiBa)
all_account_names.append(x)
if (d == "CA"):
for x in os.listdir(os.path.join(main_path, "Data", "Accounts", d)):
CA = parser.CA_Parser(
os.path.join(main_path, "Data", "Accounts", d, x, ""), KEYS)
all_accounts.append(CA)
all_account_names.append(x)
if (d == "LBB"):
for x in os.listdir(os.path.join(main_path, "Data", "Accounts", d)):
LBB = parser.LBB_Parser(
os.path.join(main_path, "Data", "Accounts", d, x, ""), KEYS)
all_accounts.append(LBB)
all_account_names.append(x)
accounts = analyse.Balance(all_accounts, all_account_names, KEYS)
accounts.include_depot(depot)
app = gui.QApplication(sys.argv)
ex = gui.App(depot, accounts, KEYS, 3)
sys.exit(app.exec_())
# initialize smtp (email sending) and imap (email recieving) protocols
receive = receive.Receive(username, password)
send = send.Send(username, password)
# send.send_message(username, "sadasd", "asdasdffasasfdsfa")
msgs = []
file_name = 'messages.data'
# if msg file exists then read from it, else retreive msgs using imap
if os.path.exists(file_name):
msgs = gui.read_from_file(file_name)
else:
for label in labels:
msgs.append(receive.get_message(category=label))
# print inbox category only
# for msg in msgs:
# print("To:\t", msg[1])
# print("Date:\t", msg[2])
# print("Subject:\t", msg[4])
# print("Content:\n", msg[5])
# print("_"*40)
# load gui
app = gui.QApplication(gui.sys.argv)
ex = gui.App(mails_lst=msgs,
my_mail=username,
send=send,
receive=receive,
labels=labels)
gui.sys.exit(app.exec_())
import resources
import gui
import sys
from PyQt5.QtWidgets import QApplication
if __name__ == '__main__':
nerd_konkurs = resources.Contest('NERD')
nerd_konkurs.load_masters()
nerd_konkurs.load_players()
nerd_konkurs.populate_sessions()
app = QApplication(sys.argv)
ex = gui.App(nerd_konkurs)
print('Goodbye World')
sys.exit(app.exec_())
#! /usr/bin/env python
#! coding:utf-8
import gui
if __name__ == "__main__":
app = gui.App(False)
app.MainLoop()
sys.exit(-1)
except:
print '>>> Unexpected exception:'
traceback.print_exc()
sys.exit(-3)
if options.disassemble:
if not options.quiet: print '--== Disasm ==--'
print disassembler.disassemble(),
if options.decompile:
if not options.quiet: print '# --== Decompile ==--'
print decompiler.decompile(),
if options.gui:
try:
import gui
gui.App(disassembler).start()
except ImportError:
print '>>> Cannot load gui. Please make sure that you ' \
'have python-tk installed on your system.'
sys.exit(-2)
else:
if args:
parser.error('incorrect number of arguments')
if len(sys.argv) == 1:
help(None, None, None, parser)
if __name__ == '__main__':
start()
import gui
import datasets as dt
import tkinter as tkr
if __name__ == "__main__":
datasetDictionary = dt.DatasetsName()
url = 'http://ec.europa.eu/eurostat/wdds/rest/data/v2.1/json/en/'
root = tkr.Tk()
root.geometry('1000x600')
root.configure(bg='#509461')
root.title('Eurostat Data')
application = gui.App(root, datasetDictionary, url)
root.mainloop()
try:
root.destroy()
except tkr.TclError:
pass
def setupGui(self):
app = gui.App(game=self)
app.mainloop()
import sys
from PyQt5.QtWidgets import QApplication
from PyQt5 import QtWidgets
import gui
def catch_exceptions(t, val, tb):
QtWidgets.QMessageBox.critical(None, "An exception was raised",
"Exception type: {}".format(t))
old_hook(t, val, tb)
old_hook = sys.excepthook
sys.excepthook = catch_exceptions
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = gui.App()
sys.exit(app.exec_())
raise RuntimeError
def testgui(qtbot):
window = gui.App()
qtbot.addWidget(window)
window.show()
assert window.isVisible()
def main():
if os.path.exists("debug_log.txt"):
os.remove("debug_log.txt")
root = tk.Tk()
app = gui.App(root, get_service())
root.mainloop()
def run(self):
"""Execute relax.
This is the application callback method executed by the multi-processor framework.
"""
# Set up the warning system.
lib.warnings.setup()
# Logging.
if self.log_file:
io_streams_log(self.log_file)
# Tee.
elif self.tee_file:
io_streams_tee(self.tee_file)
# Show the version number and exit.
if self.mode == 'version':
print('relax ' + version.version_full())
return
# Show the relax info and exit.
if self.mode == 'info':
# Initialise the information box.
info = Info_box()
# Print the program intro.
print(info.intro_text())
# Print the system info.
print(info.sys_info())
# Stop execution.
return
# Run the interpreter for the prompt or script modes.
if self.mode == 'prompt' or self.mode == 'script':
# Run the interpreter.
self.interpreter = interpreter.Interpreter()
self.interpreter.run(self.script_file)
# Execute the relax GUI.
elif self.mode == 'gui':
# Dependency check.
if not dep_check.wx_module:
sys.stderr.write(
"Please install the wx Python module to access the relax GUI.\n\n"
)
return
# Only import the module in this mode (to improve program start up speeds).
import gui
# Set the GUI flag in the status object.
status.show_gui = True
# Start the relax GUI wx application.
app = gui.App(script_file=self.script_file)
app.MainLoop()
# Execute the relax test suite
elif self.mode == 'test suite':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False,
raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_all_tests()
# Execute the relax system tests.
elif self.mode == 'system tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False,
raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_system_tests()
# Execute the relax unit tests.
elif self.mode == 'unit tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_unit_tests()
# Execute the relax GUI tests.
elif self.mode == 'GUI tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_gui_tests()
# Execute the relax verification tests.
elif self.mode == 'verification tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_verification_tests()
# Test mode.
elif self.mode == 'test':
self.test_mode()
# Licence mode.
elif self.mode == 'licence':
self.licence()
# Unknown mode.
else:
raise lib.errors.RelaxError("The '%s' mode is unknown." %
self.mode)
# exec(open("gui.py").read(), globals())
import sys
from foldercount import numfile
import gui
exec(open('gatherimages.py').read())
train_q = gui.QApplication([])
train_app = gui.App('train')
# Continue training while there are images left in /images
while numfile('./training_data/like') + numfile(
'./training_data/dislike') < numfile('./images/'):
train_app.photoChange('./images/')
train_q.quit()
predict_q = gui.QApplication([])
predict_app = gui.App('predict')
# sys.argv = ['gui.py','train']
# exec(open('gui.py').read())
# sys.argv = ['gui.py','predict']
# exec(open('gui.py').read())
import gui as g
import tkinter as tk
import random as r
import pyautogui as auto
class player:
def __init__(self):
self.to_click = ()
def get_origin(self):
self.to_click = (r.randrange(3840), r.randrange(2160))
while not game.origin_clicked:
self.right_click(self.to_click)
self.to_click = (r.randrange(3840), r.randrange(2160))
def left_click(self, coords):
auto.click(x=coords[0], y=coords[1])
def right_click(self, coords):
auto.click(x=coords[0], y=coords[1], button="right")
root = tk.Tk() # Tkinter window is created
root.lift()
root.attributes("-topmost", True) # window geometry and attributes are set
game = g.App(root)
game.mainloop()
p = player()
p.get_origin()
def main():
app = gui.App()
del app
import gui
a = gui.App()
# from Tkinter import *
# import hand
# import domino
# def removeDomino(value):
# canvas.delete(ALL)
# del b.dominoes[0]
# b.displayHand(30, 10, canvas, orientation = "H")
# print b
# def flipDomino(value):
# print str(b ) + "Before"
# canvas.delete(ALL)
# b.dominoes[0].flip()
# b.displayHand(30, 10, canvas, orientation = "H")
# print str(b) + "After"
# root = Tk()
# canvas = Canvas(root, width = 400, height = 200)
# canvas.pack()
# a = [domino.Domino(), domino.Domino(), domino.Domino(), domino.Domino()]
# print a
# # for i in xrange(1, len(a) + 1):
# # a[i-1].displayValue(canvas, x = i* 60, y = 10, orientation = "H")
# #a.displayValue(canvas, 30, 10, orientation = "H")
