def main():
"""Main function of Ex.Co."""
# Check arguments
options = parse_arguments()
if options.debug_mode == True:
data.debug_mode = True
if options.logging_mode == True:
data.logging_mode = True
file_arguments = options.files
if options.single_file != None:
if file_arguments != None:
file_list = file_arguments.split(";")
file_list.append(options.single_file)
file_arguments = ";".join(file_list)
else:
file_arguments = [options.single_file]
if file_arguments == ['']:
file_arguments = None
# Create QT application, needed to use QT forms
app = data.QApplication(sys.argv)
# Save the Qt application to the global reference
data.application = app
# Set default application font
components.fonts.set_application_font(
data.current_font_name,
data.current_font_size,
)
# Create the main window, pass the filename that may have been passed as an argument
main_window = gui.MainWindow(new_document=options.new_document,
logging=data.logging_mode,
file_arguments=file_arguments)
components.TheSquid.init_objects(main_window)
main_window.import_user_functions()
main_window.show()
sys.exit(app.exec_())
def __init__(self):
self._pyaudio = pyaudio.PyAudio()
self._audiostream = self._pyaudio.open(format=pyaudio.paInt16,
channels=2,
rate=44100,
output=True)
self._dbpath = pathlib.Path('./music.db')
self._db = musicdb.MusicDB(self._dbpath)
self.curtrack = self._db.getcurrenttrack()
self.nexttrack = self._db.getnexttrack()
self._nextrequested = False
self._prevrequested = False
self.playing = False
self._cache = Cache()
self._cache.cachetrack(self.curtrack['path'])
self._cache.cachetrack(self.nexttrack['path'])
self._gui = gui.MainWindow(self)
self._gui.show()
self._gui.setPaused()
self._gui.setTrackInfo(self.curtrack)
# DB will be reopened in the playing thread
self._db = None
self._thread = threading.Thread(target=self._mainloop)
self._thread.start()
def parseArgs(self, argv):
for idx, val in enumerate(argv):
if(val[0] == '-'):
if(val == '-v' or val == '--verbose'):
self.VERBOSITY = "VERBOSE"
elif(val == '-q' or val == '--quiet'):
self.VERBOSITY = "QUIET"
elif(val == '-qe'):
self.VERBOSITY = "QUIETWITHERRORS"
elif(val == '-l'):
self.OUTPUTFORMAT = "LIST"
elif(val == '-h'):
self.OUTPUTFORMAT = "HUMAN"
elif(val == '-d'):
self.DEPTH = self.__getPosNumFlagArgument('-d', argv, idx)
elif(val == '-s' or val == "--maxsize"):
self.MAXFILESIZE = self.__getPosNumFlagArgument('-s', argv, idx)
elif(val == '-g' or val == '--gui'):
app = wx.App(False)
frame = gui.MainWindow(None, "Uniquity -- The Unique File Analyzer")
app.MainLoop()
exit(0)
elif(val == '--algorithm'):
self.HASHALG = self.__getStrArgument(idx)
if(self.HASHALG not in hashlib.algorithms):
sys.stderr.write("Error: '"+self.HASHALG+"' Not an available algorithm.\n")
exit(1)
else:
sys.stderr.write("Flag: '" + val + "' Not recognized.\n")
exit(1)
else:
self.files.append(val)
def setup_GUI():
widget = QStackedWidget()
widget.setWindowTitle("Quantum TicTacToe")
window = gui.MainWindow(widget)
widget.addWidget(window)
widget.show()
return widget
def on_activate(self, app):
"""Starts SpiceGUI.
``activate`` signal handler.
Args:
app: Appliction.
"""
window = gui.MainWindow()
app.add_window(window)
window.show_all()
def main():
"""Main function of Ex.Co."""
#Check arguments
options = parse_arguments()
if options.debug_mode == True:
data.debug_mode = True
if options.logging_mode == True:
data.logging_mode = True
file_arguments = options.files
if options.single_file != None:
if file_arguments != None:
file_list = file_arguments.split(";")
file_list.append(options.single_file)
file_arguments = ";".join(file_list)
else:
file_arguments = [options.single_file]
if file_arguments == ['']:
file_arguments = None
#Get the application directory
if getattr(sys, 'frozen', False):
# frozen
data.application_directory = os.path.dirname(sys.executable).replace(
"\\", "/")
else:
# unfrozen
data.application_directory = os.path.dirname(
os.path.realpath(__file__)).replace("\\", "/")
#Check if Ex.Co. is run as a cx_freeze executable (the path will contain library.zip)
if data.application_directory.endswith(".zip"):
data.application_directory = os.path.dirname(
data.application_directory)
#Set the resources directory
data.resources_directory = os.path.join(data.application_directory,
"resources")
#Combine the application path with the Ex.Co. icon file name (the icon file name is set in the global module)
data.application_icon = os.path.join(data.resources_directory,
data.application_icon)
#Combine the application path with the Ex.Co. information file name (the information file name is set in the global module)
data.about_image = os.path.join(data.resources_directory, data.about_image)
#Create QT application, needed to use QT forms
app = data.QApplication(sys.argv)
#Save the Qt application to the global reference
data.application = app
#Create the main window, pass the filename that may have been passed as an argument
main_window = gui.MainWindow(new_document=options.new_document,
logging=data.logging_mode,
file_arguments=file_arguments)
components.TheSquid.init_objects(main_window)
main_window.import_user_functions()
main_window.show()
sys.exit(app.exec_())
def __init__(self):
parser = optparse.OptionParser(usage='Usage %prog -a <car IP>\n -p <car PASSWORD>' +
'Optional:\n --videoport <video port> --controlport <controls port>')
parser.add_option('-a', dest='car_addr', type='string')
parser.add_option('-p', dest='car_pass', type='string')
parser.add_option('--videoport', dest='video_port', type='int', default=16168)
parser.add_option('--controlport', dest='controls_port', type='int', default=16169)
parser.add_option('--detection', action='store_true', dest='detection',
default=False, help="Enable object detection.")
(options, args) = parser.parse_args()
if options.car_addr is None:
print(parser.usage)
exit(1)
# Store options to a global static class
config.car_addr = options.car_addr
config.car_pass = options.car_pass
config.video_port = options.video_port
config.controls_port = options.controls_port
detection = options.detection
# Establish connection.
#host = '127.0.0.1'
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind(('', config.controls_port))
# Send LOGON request along with entered password to the car.
msg = 'LOGON ' + config.car_pass
self.sock.sendto(msg.encode(), (config.car_addr, config.controls_port))
# Store pointer to the control socket in a static global variable, so it can easily be
# used elsewhere.
config.controls_sock = self.sock
# Wait for approval.
self.sock.settimeout(10)
print("Waiting for car to respond...")
msg, addr = self.sock.recvfrom(1024)
if msg.decode() == 'CONNECTED':
print("Connection SUCCESS!")
self.sock.settimeout(None)
# Start to listen for video feed
self.video_player = video.VideoPlayer(detection)
self.video_player.start()
# Send confirmation, that the controller is now listening for video connection.
self.sock.sendto("VIDEO OK".encode(), (config.car_addr, config.controls_port))
# Open QT window for controlling the car.
gui.MainWindow()
self.finish()
def on_open(self, app, files, hint, user_data):
"""Opens circuit file from command line.
``open`` signal handler.
Args:
app: Appliction.
files: An array of Gio.Files.
hint: A hint provided by the calling instance.
user_data: User-defined data.
"""
for _file in files:
window = gui.MainWindow(_file.get_path())
app.add_window(window)
window.show_all()
def sniff(red, protocol=[], ipDes='', ipSrc='', num=10):
destination = 'dst ' + ipDes
source = 'src ' + ipSrc
fil = ''
if ipDes == '':
destination = ''
else:
fil += destination
if ipSrc == '':
source = ''
else:
fil += ' and ' + source
if protocol != []:
fil += ' and ' + " and ".join(protocol)
pockets = all.sniff(iface=red, count=num, filter=fil)
# Diccionario para pasarle a la interfaz grafica
datos = []
#print("----------------------------------Frames----------------------------------")
for i, p in enumerate(pockets):
"""
print("----------------------------------Frame "+str(i+1)+" ----------------------------------")
print("Preambule: 10101011")
print("Source: {}".format(p.src))
print("Destination: {}".format(p.dst))
print("Type: {}".format(p.type))
print("Payload: {}".format(p.payload))
print("Summary: {}".format(p.summary()))
print("Datagram:")
print(all.hexdump(p))
"""
datos.append({
'preambule': 10101011,
'source': p.src,
'destination': p.dst,
'type': p.type,
'payload': p.payload,
'summary': p.summary(),
'datagram': all.hexdump(p, dump=True)
})
# Inicia la interfaz grafica
gui.MainWindow(num, datos)
def __init__(self):
os.environ['PYGTK_FATAL_EXCEPTIONS'] = '1'
data.Generic.setApplicationReference(self)
self.mainwin = gui.MainWindow(self)
self.quitrequest = False
self.tracker = glue.threads.Tracker(self)
self.tracker.start()
self.state = self.STATE_LOGGEDOUT
self.activeProfile = None
self.instanceTypes = []
if not os.path.exists(os.path.expanduser('~/.skarphedadmin/')):
os.mkdir(os.path.expanduser('~/.skarphedadmin/'))
logging.basicConfig(
filename=os.path.expanduser('~/.skarphedadmin/generic.log'),
level=logging.DEBUG)
AutoSaveThread(self).start()
from data import skarphed
def main(args=None):
"""The main routine."""
if args is None:
args = sys.argv[1:]
#CompanyListParser.CompanyListParser().callme();
#parser = companydataparser.CompanyDataParser(
# "https://www.corporateaffiliations.com/Subscriber/HistoricalComparison?selName=Aastrom+Biosciences%2c+Inc.&selID=000139270-0000&selYear=2015"
#)
#parser.load()
#parser.parse(1)
# h=hierarchyparser.HierarchyParser("http://www.cyberlink.com")
# h.parse()
#parserController = controller.ParserController(["/Users/man9527/Downloads/2836"])
#parserController.run()
gui.MainWindow().show()
#!/usr/bin/env python3
import gui
if __name__ == '__main__':
lukr_gui = gui.MainWindow()
lukr_gui.run()
#!/usr/bin/python import Tkinter as tk import gui import database as db from client import RpcClient root = tk.Tk() #print gui.ask_login(root) #rpc_client = db.get_rpc_client() # login_dlg = LoginForm(master=root) # login_dlg.transient(root) # only one window in the task bar # login_dlg.grab_set() # modal #else: #mw = MainWindow(root, rpc_client) must_login = not db.get_rpc_client() rpc = RpcClient() mw = gui.MainWindow(root, rpc, must_login=must_login) # root.mainloop() root.update() d = gui.MyDialog(root) root.wait_window(d.top)
sys.__excepthook__(exctype, value, tb)
# close previous window if multiple exceptions occur
try:
self.w.close()
except AttributeError:
pass
self.w = gui.CrashPop(exc)
self.w.setup()
if __name__ == "__main__":
# set exception handler for exceptions in qt app event loop
sys.excepthook = ExceptionHandler().handler
# create org and app folders if not found
app = QtWidgets.QApplication(sys.argv)
app.setOrganizationName("Right_Rebels")
app.setApplicationName("World Temperature Anomaly Map")
app.setStyle("Fusion")
path = QtCore.QStandardPaths.writableLocation(QtCore.QStandardPaths.AppConfigLocation)
if not os.path.isdir(path):
if not os.path.isdir(path[:path.rfind("/")]):
os.mkdir(path[:path.rfind("/")])
os.mkdir(path)
settings = QtCore.QSettings(path + "/config.ini", QtCore.QSettings.IniFormat)
ui = gui.MainWindow(settings)
ui.setup_ui()
sys.exit(app.exec_())
def run(*args, **kw):
"""
Call with::
[-d, <description>,] [-N, <values>,]
[-o, <imageFile>,]
[-g,] [-s,]
Nx, cr, ci, crPM, [ciPM]
Writes PNG image to stdout unless -o is set, then saves it to
C{imageFile}. In that case, prints some stats about the
multiprocessing computation to stdout.
Options-as-arguments:
- B{d}: An endpoint I{description} of a server running a
L{wire.server}.
- B{s}: Show image (B{TODO})
@keyword N_values: Integer number of possible values for
Mandelbrot points during iteration. Can set with the C{-N
values} arg instead.
@keyword ignoreReactor: Set C{True} to let somebody else start and
stop the reactor.
"""
@defer.inlineCallbacks
def reallyRun():
if description:
myRunner = wire.RemoteRunner(description)
yield myRunner.setup(N_values=N_values)
else:
myRunner = runner.Runner(N_values, stats)
runInfo = yield myRunner.run(fh, Nx, cr, ci, crPM, ciPM)
if stats:
yield myRunner.showStats(runInfo)
yield myRunner.shutdown()
if not ignoreReactor:
reactor.stop()
defer.returnValue(runInfo)
def getOpt(opt, default=None):
optCode = "-{}".format(opt)
if optCode in args:
k = args.index(optCode)
args.pop(k)
if default is None:
return
optType = type(default)
return optType(args.pop(k))
return default
ignoreReactor = kw.pop('ignoreReactor', False)
if not args:
args = sys.argv[1:]
args = list(args)
show = getOpt('s')
N_values = getOpt('N', 2000)
fileName = getOpt('o', "")
description = getOpt('d', "")
useGUI = getOpt('g')
if fileName:
stats = True
fh = open(fileName, 'w')
else:
stats = False
fh = sys.stdout
if len(args) < 4:
print(
"Usage: [-N values] "+\
"[-o imageFile] [-d description] [-g] [-s] " +\
"N cr ci crPM [ciPM]")
sys.exit(1)
Nx = int(args[0])
cr, ci, crPM = [float(x) for x in args[1:4]]
ciPM = float(args[4]) if len(args) > 4 else crPM
if useGUI:
raise NotImplementedError("GUI not yet implemented")
# TODO
from PyQt4 import QtGui
import qt4reactor
import gui
app = QtGui.QApplication(sys.argv)
qt4reactor.install()
w = gui.MainWindow(Nx, cr, ci, crPM)
reactor.run()
elif ignoreReactor:
return reallyRun()
else:
reactor.callWhenRunning(reallyRun)
reactor.run()
import logging
from Tkinter import Image
import gui
import server as s
import client as c
from syncIO import SyncConsoleAppenderRawInputReader
FORMAT = '%(asctime)-15s %(levelname)s %(message)s'
logging.basicConfig(level=logging.DEBUG, format=FORMAT)
LOG = logging.getLogger()
if __name__ == "__main__":
# Create ui
ui = gui.MainWindow()
# Set icon
# https://cdn2.iconfinder.com/data/icons/games-and-sports-vol-2/32/Game_sports_calculate_counting_crosswords_numbers_sudoku-512.png
#ui.tk.call('wm',
# 'iconphoto',
# ui._w,
# Image("photo", file="icon.png"))
# Create game
game = s.Game()
# Pre-set server with game
server = s.GameServer(game)
# Create client
# TODO: remove syncIO dependency for GUI
sync_io = SyncConsoleAppenderRawInputReader()
client = c.Client(sync_io)
def main():
app = qapplication()
window = gui.MainWindow()
window.show()
app.exec_()
import smtplib
import game_module
from point import Point
import time
import sys
from PyQt5.QtWidgets import QApplication
import gui
def send_email(host, username, password, subject, to_addr, body_text):
"""
Send an email
"""
BODY = "\r\n".join(("From: %s" % username, "To: %s" % to_addr,
"Subject: %s" % subject, "", body_text))
server = smtplib.SMTP_SSL('smtp.yandex.com')
server.set_debuglevel(1)
server.ehlo(username)
server.login(username, password)
server.auth_plain()
server.sendmail(username, [to_addr], BODY)
server.quit()
if __name__ == '__main__':
app = QApplication(sys.argv)
window = gui.MainWindow()
sys.exit(app.exec_())
configuration_file_path = config_path.ConfigPath('pynfinitton',
'creatingfuture.eu',
'.ini')
device_manager = logic.DeviceManager(configuration_file_path)
# If graphical
app = QApplication(sys.argv)
translator = QTranslator()
translator.load(QLocale(device_manager.locale),
'pynfinitton',
'.',
directory=os.path.join(path, 'resources', 'translations'))
app.installTranslator(translator)
window = gui.MainWindow(device_manager)
window.resize(800, 600)
if device_manager.open_on_start:
window.show()
tray_icon_menu = gui.TrayIconMenu(window)
tray_icon = QSystemTrayIcon(QIcon('resources/ui/light/app_icon.png'),
window)
tray_icon.setToolTip("Pynfinitton")
tray_icon.setContextMenu(tray_icon_menu)
tray_icon.show()
sys.exit(app.exec_())
def main(argv):
app = QApplication(argv)
mainwindow = gui.MainWindow()
mainwindow.show()
sys.exit(app.exec_())
# KUR-dev-machine
#map <F8> :wa<CR>:lcd /home/kur/dev/SickZil-Machine/src<CR>:!python main.py<CR>
#map <F5> :wa<CR>:lcd /home/kur/dev/SickZil-Machine/test<CR>:!pytest -vv<CR>
# KUR-LAB-MACHINE
#map <F8> :wa<CR>:lcd /home/kur/dev/szmc/SickZil-Machine/src<CR>:!python main.py<CR>
#map <F5> :wa<CR>:lcd /home/kur/dev/szmc/SickZil-Machine/test<CR>:!pytest -vv<CR>
import sys
from PyQt5.QtWidgets import QApplication
from PyQt5.QtQml import QQmlApplicationEngine
import gui
import consts
import core
if __name__ == '__main__':
consts.load_config('../resource/config.json')
core.set_limits(
consts.config['seg_limit'],
consts.config['compl_limit']
)
app = QApplication(sys.argv)
engine = QQmlApplicationEngine()
main_window = gui.MainWindow(engine)
sys.exit(app.exec_())
def __init__(self):
self.sg=Signals() #инициализируем сигналы
self.app=QApplication(sys.argv) #создаем экземпляр приложения
self.window=gui.MainWindow(self) #подгружаем итерфейс окна из gui.py
self.window.sg.lists.connect(self.get_rest) #подключаем слот-функцию get_rest на появление сигнала sg.list из gui.py
def main():
gui.MainWindow().show()
#!/usr/bin/python3 # -*- coding: utf-8 -*- import sys import gui files = sys.argv[1:] gui_obj = gui.MainWindow(files)
def __init__(self):
super(Application, self).__init__()
self.frame = gui.MainWindow(None, config.WINDOW_TITLE,
config.MAIN_WINDOW_SIZE)
self.pageWidth = 0
self.pageHeight = 0
self.pageBitmap = None
self.xml = None
self.pdf = None
self.networkDocumentId = None
self.selectionCorners = None
self.pageCount = 0
self.pageIndex = 0
self.frame.setPage(0, 0)
self.zoom = config.DEFAULT_ZOOM
self.frame.setZoom(self.zoom)
self.mode = MERGE
self.frame.switchMode(self.mode)
self.layer = WORD
self.frame.switchLayer(self.layer)
self.frame.enableMenuItems(sendNet=False, openPDF=False, closeXML=False,
closePDF=False, save=False, saveAs=False, undo=False, redo=False)
pub.subscribe(self.pageChangeMsg, "FIRSTPAGE")
pub.subscribe(self.pageChangeMsg, "PGUP")
pub.subscribe(self.pageChangeMsg, "CHANGE_PAGE")
pub.subscribe(self.pageChangeMsg, "PGDOWN")
pub.subscribe(self.pageChangeMsg, "LASTPAGE")
pub.subscribe(self.zoomChangeMsg, "ZOOMIN")
pub.subscribe(self.zoomChangeMsg, "ZOOMOUT")
pub.subscribe(self.zoomChangeMsg, "CHANGE_ZOOM")
pub.subscribe(self.setModeMsg, "MODE_MERGE")
pub.subscribe(self.setModeMsg, "MODE_CUTOUT")
pub.subscribe(self.setModeMsg, "MODE_CLASSIFY")
pub.subscribe(self.setLayerMsg, "LAYER1")
pub.subscribe(self.setLayerMsg, "LAYER2")
pub.subscribe(self.setLayerMsg, "LAYER3")
pub.subscribe(self.changeModeMsg, "CHANGE_MODE")
pub.subscribe(self.changeLayerMsg, "CHANGE_LAYER")
pub.subscribe(self.paintScroll, "PAINT")
pub.subscribe(self.openNet, "OPENNET")
pub.subscribe(self.sendNet, "SENDNET")
pub.subscribe(self.openXML, "OPENXML")
pub.subscribe(self.openPDF, "OPENPDF")
pub.subscribe(self.saveXML, "SAVEXML")
pub.subscribe(self.saveXML, "SAVEXMLAS")
pub.subscribe(self.closeXML, "CLOSEXML")
pub.subscribe(self.closePDF, "CLOSEPDF")
pub.subscribe(self.undoRedoMsg, "UNDO")
pub.subscribe(self.undoRedoMsg, "REDO")
pub.subscribe(self.closeApp, "CLOSEAPP")
pub.subscribe(self.popupMenuMsg, "POPUPMENU")
pub.subscribe(self.atomizeMsg, "ATOMIZE")
pub.subscribe(self.smartSplitMsg, "SMART_SPLIT")
pub.subscribe(self.classifyMsg, "CLASSIFY")
pub.subscribe(self.documentChangeMsg, "DOCUMENT_CHANGE")
pub.subscribe(self.scrollLeftDownMsg, "SCROLL_LEFT_DOWN")
pub.subscribe(self.scrollMoveMsg, "SCROLL_MOVE")
pub.subscribe(self.scrollLeaveMsg, "SCROLL_LEAVE")
pub.subscribe(self.scrollLeftUpMsg, "SCROLL_LEFT_UP")
self.MainLoop()
def main():
win = gui.MainWindow()
win.show()
import sys
from PyQt5.QtWidgets import *
import gui
import Infiltration as inf
if __name__ == "__main__":
#show main window
app = QApplication(sys.argv)
ex = gui.MainWindow()
sys.exit(app.exec_())
import gui
import sys
from PyQt5.QtWidgets import QApplication
if __name__ == '__main__':
app = QApplication(sys.argv)
w_app = gui.MainWindow()
sys.exit(app.exec_())
from PyQt5.QtCore import QUrl
import numpy as np
import cv2
import utils.fp as fp
import utils.futils as fu
import gui
import state
import consts
consts.load_config()
import core
import imgio as io
app = QApplication(sys.argv)
main_window = gui.MainWindow(
QQmlApplicationEngine()
)
@pytest.fixture
def clear_state():
state.clear_all()
def fpath(*ps):
return str(PurePosixPath(*ps))
def posix_abspath(path):
abspath = os.path.abspath(path)
return(abspath.replace('\\','/') if '\\' in abspath
else abspath)
def open_project(prjdir):
abspath = os.path.abspath(prjdir)
choice = choices[choice](*args)
else:
print("Invalid selection. Choose:",
', '.join([k for k in choices.keys()]))
choice = ''
return
if __name__ == "__main__":
fileName = 'Error Logs/Error Log - ' + datetime.datetime.strftime(
datetime.datetime.now(), '%I_%M_%S_%p') + '.log'
logging.basicConfig(filename=fileName, level=logging.DEBUG, filemode='w')
try:
if False:
import gui
gui.MainWindow().run()
else:
start = time.time()
ctypes.windll.kernel32.SetConsoleTitleW("Idle Gods Controller X")
args = [''] * len(sys.argv)
if len(sys.argv) > 1:
for x in range(1, len(sys.argv)):
args[x - 1] = sys.argv[x]
askChoice(*args)
except SystemExit:
pass
except BaseException:
logging.getLogger(__name__).exception("Program terminated")
logging.debug("Ran for: " + utils.formatTime(int(time.time() - start)))
raise
logging.shutdown()
