class MusicPlayerApplication(Gtk.Application): APP_NAME = "MusicPlayer" APP_CONFIG_PATH = "musicplayer" def __init__(self): Gtk.Application.__init__(self) GLib.set_application_name(self.APP_NAME) self.win = None self.settings = None self.discoverer = None self.player = None self.equalizer = None self.queue = None self.history = None self.integration = None def do_startup(self): Gtk.Application.do_startup(self) self.settings = Settings(self) self.discoverer = Discoverer() self.player = Player(self) self.equalizer = Equalizer(self) self.queue = Queue(self) self.history = History(self) self.integration = Integration(self) self.win = MainWindow(self) def do_activate(self): self.win.show_all()
def render(self): app = QApplication(sys.argv) self.config_window = ConfigWindow() self.stat_window = ClientStatsWindow() self.main_window = MainWindow() self.show_main_window() self.make_signals_connection() app.exec_()
def transition_to_main_window(project): logging.info("Transitioning to main window.") global main_window driver = Driver(project) settings_service.save_settings() main_window = MainWindow(transition_back_to_create_project, driver) main_window.show()
class MainState(State): def __init__(self): super().__init__("Main") self.window = None def act(self): logging.info("Entered Main state.") self.window = MainWindow() self.window.show()
def do_startup(self): Gtk.Application.do_startup(self) self.settings = Settings(self) self.discoverer = Discoverer() self.player = Player(self) self.equalizer = Equalizer(self) self.queue = Queue(self) self.history = History(self) self.integration = Integration(self) self.win = MainWindow(self)
def __init__(self): app = QApplication(sys.argv) width = app.desktop().screenGeometry().width() height = app.desktop().screenGeometry().height() Connection() # Initializing database connection load_setting() # Load Setting from config load_url() # Load URL List from json file w = MainWindow(width, height, "Skreepy") w.setVisible(True) sys.exit(app.exec_())
def __init__(self): self.m_settings = None self.m_parser = None self.m_window = None self.m_connected = False self.m_auto_start = False self.m_full_screen = False self.clutch_pedal_effect = None self.brake_pedal_effect = None self.throttle_pedal_effect = None self.m_udp_host = Parser.UDP_IP self.m_udp_port = Parser.UDP_PORT self.m_game = Games.DIRT_RALLY self.ardui_dash = None self.arduino_com_port = None self.arduino_baud_rate = None self.arduino_auto_start = False self.last_ui_update = None qt_app = QtWidgets.QApplication(sys.argv) qt_app.quitOnLastWindowClosed() self.m_window = MainWindow.init_from_ui(self) self.load_preferences() prefix_path = '' if getattr(sys, 'frozen', False): # noinspection PyUnresolvedReferences,PyProtectedMember prefix_path = sys._MEIPASS + '/' self.m_window.clutch_label.setPixmap( QtGui.QPixmap(prefix_path + 'res/images/clutch.png')) self.m_window.brake_label.setPixmap( QtGui.QPixmap(prefix_path + 'res/images/brake.png')) self.m_window.throttle_label.setPixmap( QtGui.QPixmap(prefix_path + 'res/images/throttle.png')) self.fill_games_menu() self.clear_ui() self.ardui_dash = ArduiDash() if GUI is True: if self.m_full_screen is True: self.m_window.showFullScreen() self.hide_toolbars() else: self.m_window.show() if DEBUG is True: self.m_parser.enable_parser_debug(flags.log_level) self.ardui_dash.enable_debug(flags.log_level) if self.m_auto_start is True: self.start() sys.exit(qt_app.exec_()) else: self.m_parser.enable_parser_debug(2) self.ardui_dash.enable_debug(2) self.start()
def sign_up(self, login, password, name): user = User(login = login, password=password, fullname = str(name)) try: self.auth_service.create_new_user(user) messagebox.showinfo(message="User created.") self.window.destroy() self.window = Tk() MainWindow(self.window, user.id, Services.product_service(), Services.user_service(), Services.physical_stats_service()) except: messagebox.showinfo(message="User with that login already exists.")
def sign_in(self, login, password): user = User(login = login, password = password) try: user_from_db = self.auth_service.verify_user(user) self.window.destroy() self.window = Tk() MainWindow(self.window, user_from_db.id, Services.product_service(), Services.user_service(), Services.physical_stats_service()) except Exception as e: messagebox.showinfo(message="Wrong login or password.")
def show_main_window(self): self.main_window = MainWindow(self.client.client_name) self.main_window.logout_signal.connect(self.logout) self.main_window.start_chatting_signal.connect(self.start_chatting) self.main_window.send_message_signal.connect(self.send_message) self.main_window.switch_to_add_contact.connect(self.show_add_contact_window) self.main_window.switch_to_del_contact.connect(self.show_del_contact_window) self.make_main_window_signals_connection() self.main_window.set_elements_disable_status(True) self.main_window.render_welcome_message() contacts = self.get_contacts() self.main_window.render_contacts(contacts) if self.login_window: self.login_window.close() if self.signup_window: self.signup_window.close() self.main_window.show()
def run(): import argparse parser = argparse.ArgumentParser() parser.add_argument( '-m', dest='module', default='pynodegl_utils.examples', help='set the module name containing the scene functions') parser.add_argument( '-a', dest='assets_dir', help='set the assets directory to be used by the scene functions') parser.add_argument('--hooks-dir', dest='hooksdir', help='set the directory path containing event hooks') pargs = parser.parse_args(sys.argv[1:]) app = QtWidgets.QApplication(sys.argv) window = MainWindow(pargs.module, pargs.assets_dir, pargs.hooksdir) window.show() app.exec_()
def main(argv): """ Program entry point argv: Command line args (excluding the script name) """ # Load the ship registry script_path = os.path.dirname(os.path.abspath(__file__)) ships_json = os.path.join(script_path, "data", "ship_registry.json") ship_registry = ShipRegistry(ships_json) # Load the pilot registry pilots_json = os.path.join(script_path, "data", "pilot_registry.json") pilot_registry = PilotRegistry(pilots_json, ship_registry) # Create the board board = Board() # Create players for each side player1 = ConsolePlayer(Faction.imperial, board) player2 = ConsolePlayer(Faction.rebel, board) # Wrap these all up in the game object game = Game(board, [player1, player2], pilot_registry) # Create the game thread and set it running game_thread = GameThread(game) # Build the UI and set it running root = tk.Tk() app = MainWindow(board, master=root) try: app.mainloop() except KeyboardInterrupt: pass # Once the main window is closed, join the game thread game_thread.join() return 0
def main(): app = QgsApplication([], True) app.setPrefixPath("C:/OSGeo4W64/apps/qgis", True) app.initQgis() window = MainWindow() window.show() window.raise_() bb = (635432, 5616219, 635939, 5616575) # WestSouthEastNorth # bb = (633612, 5619141, 634424, 5619713) # highway # # streets streetsPath = ("files/cir/streets.shp") osmStreets = OsmStreets(extent=bb, extentEPSG=25832) osmStreets.getBufferedStreets(savePath=streetsPath) loadVectorLayer(streetsPath, "streets") streetMaskPath = ("files/cir/streets_mask.tiff") vector2raster(bb, streetsPath, streetMaskPath) loadRasterLayer(streetMaskPath, "streetsMask") # clipping dop with streetMask dop = ("files/colour/streets_dop.tif") clippedPathTemp = ("files/colour/streets_clipped_temp.tiff") clipping(streetMaskPath, dop, clippedPathTemp) # copy extent and EPSG from streetMaskPath clippedPath = ("files/colour/streets_clipped.tiff") CopyExtentandEPSG(streetMaskPath, clippedPathTemp, clippedPath) loadRasterLayer(clippedPath, "clippedSteets") # # # buildings # buildingsPath = ("files/buildings.shp") # osmBuildings = OsmBuildings(extent=bb, extentEPSG=25832) # osmBuildings.getBuildingPolygons(savePath=buildingsPath, onlyWithHeight=False) # loadVectorLayer(buildingsPath, "buildings") # buildingMaskPath = ("files/buildings.tiff") # vector2raster(bb, buildingsPath, buildingMaskPath) # loadRasterLayer(buildingMaskPath, "buildingsMask") # water # waterPath = "files/water.shp" # osmWater = OsmWater(extent=bb, extentEPSG=25832) # osmWater.getWaterPolygons(savePath=waterPath) # loadVectorLayer(waterPath, "water") # waterMaskPath = "files/water.tiff" # vector2raster(bb, waterPath, waterMaskPath) # loadRasterLayer(waterMaskPath, "waterMask") # set CRS to the one of image and zoom to extent crs = QgsCoordinateReferenceSystem() crs.createFromId(25832) window.canvas.setDestinationCrs(crs) exitcode = app.exec_() QgsApplication.exitQgis() sys.exit(exitcode)
def run(): import argparse parser = argparse.ArgumentParser() parser.add_argument( '-m', dest='module', default='pynodegl_utils.examples', help='set the module name containing the scene functions') parser.add_argument( '-a', dest='assets_dir', help='set the assets directory to be used by the scene functions') parser.add_argument('--hooks-dir', dest='hooksdir', help='set the directory path containing event hooks') pargs = parser.parse_args(sys.argv[1:]) app = QtWidgets.QApplication(sys.argv) # Fixes ui freezes with the native gl view on macos 10.14 (mojave) app.setAttribute(QtCore.Qt.AA_DontCreateNativeWidgetSiblings) window = MainWindow(pargs.module, pargs.assets_dir, pargs.hooksdir) window.show() app.exec_()
def __init__(self,ip='',port=9011,peer_id=-1,build_ui = True, log = None): # Node state if ip == '': self.ip = self._getIP() else: self.ip = ip if not log: log = Log('livesession') self.id = peer_id self.port = port self.log = log self.name = '{0}:{1}'.format(self.ip,port) self.state = PeerState(peer_id, self.log) self.state.ip = self.ip self.state.port = self.port self.state.ips.append(self.state.ip) self.state.ports.append(self.state.port) # Print start log.blue('\n\nINIT', self.id) log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3)) self.log.blue(self.ip, ":", self.port) log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3)) # Init main UI if build_ui: self.window = MainWindow(self.state) self.window.show() self.window.raise_() self.state.window = self.window self.state.newStrokesSignal.connect(self.window.scribbleArea.strokesSignalHandler) # Handler for the RPC requests self.RPCresponder = RPCresponder(self.state) # Accept incoming connections in a background thread self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False) self.server.server_bind() self.server.server_activate() self.server.register_introspection_functions() self.server.register_instance(self.RPCresponder) t = Thread(target = self._run,name='{0}:{1}'.format(ip,port)) t.daemon = True t.start()
def run(self): print('Waiting to initial connection to server...') while not self.servers_db.selected: ip = Ip(self.queue.get()) if ip.protocol != 6: continue tcp = Tcp(ip.data) if len(tcp.data) == 4 and tcp.data.get_array_int(1) == [1, 0, 0, 0]: self.servers_db.selected = self.servers_db[ip.source_addr] print('Conected to: ' + self.servers_db.selected['name']) MainWindow().SetServerName(self.servers_db.selected['name']) while len(self.server_keys) < 2 or len(self.client_keys) < 2: ip = Ip(self.queue.get()) if ip.protocol != 6 or (ip.source_addr != self.servers_db.selected['ip'] and ip.destination_addr != self.servers_db.selected['ip']): continue tcp = Tcp(ip.data) if tcp.data.len() == 128: if ip.source_addr == self.servers_db.selected['ip']: # received self.server_keys.append(tcp.data) else: # sent self.client_keys.append(tcp.data) self.session = Session(self.server_keys, self.client_keys) SkillDatabase().read(self.servers_db.selected['location']) HotDotDatabase().read(self.servers_db.selected['location']) NpcDatabase().read(self.servers_db.selected['location']) while self.enable: ip = Ip(self.queue.get()) if ip.protocol != 6 or (ip.source_addr != self.servers_db.selected['ip'] and ip.destination_addr != self.servers_db.selected['ip']): continue tcp = Tcp(ip.data) if not tcp.data.len(): continue if ip.source_addr == self.servers_db.selected['ip']: # received self.session.encrypt(tcp.data) self.s_splitter.add_data(tcp.data) else: # sent self.session.decrypt(tcp.data) self.c_splitter.add_data(tcp.data)
from tkinter import Tk from ui.main_window import MainWindow if __name__ == '__main__': root = Tk() mw = MainWindow(root) root.mainloop()
import resource import sys from PyQt5.QtWidgets import QApplication from ui.main_window import MainWindow if __name__ == "__main__": # Increasing size of stack to be able to pickle print(resource.getrlimit(resource.RLIMIT_STACK)) print(sys.getrecursionlimit()) max_rec = 0x100000 # May segfault without this line. 0x100 is a guess at the size of each stack frame. resource.setrlimit(resource.RLIMIT_STACK, [0x100 * max_rec, resource.RLIM_INFINITY]) sys.setrecursionlimit(max_rec) app = QApplication(sys.argv) mySW = MainWindow() mySW.show() sys.exit(app.exec_())
import qdarkstyle from PyQt5.QtCore import Qt from PyQt5.QtWidgets import QApplication, QMessageBox from ui.main_window import MainWindow if __name__ == '__main__': app = QApplication([]) app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) if os.path.isfile('config.json'): with open('config.json') as f: config = json.load(f) application = MainWindow(app, config) # Disable window resize and the maximize button application.setWindowFlags(Qt.WindowCloseButtonHint | Qt.WindowMinimizeButtonHint) application.show() application.setFixedSize(application.size()) sys.exit(app.exec_()) else: msg = QMessageBox() msg.setWindowTitle('Config missing') msg.setText( """<p style='text-align: center;'><img src='ui/assets/warning-icon.png' alt='' width='42' height='42'/></p> <p style='align: center;'><strong>config.json file is missing, cannot continue !</strong></p>"""
class Peer: def __init__(self,ip='',port=9011,peer_id=-1,build_ui = True, log = None): # Node state if ip == '': self.ip = self._getIP() else: self.ip = ip if not log: log = Log('livesession') self.id = peer_id self.port = port self.log = log self.name = '{0}:{1}'.format(self.ip,port) self.state = PeerState(peer_id, self.log) self.state.ip = self.ip self.state.port = self.port self.state.ips.append(self.state.ip) self.state.ports.append(self.state.port) # Print start log.blue('\n\nINIT', self.id) log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3)) self.log.blue(self.ip, ":", self.port) log.blue('-'*(len(self.ip.__str__())+len(self.port.__str__())+3)) # Init main UI if build_ui: self.window = MainWindow(self.state) self.window.show() self.window.raise_() self.state.window = self.window self.state.newStrokesSignal.connect(self.window.scribbleArea.strokesSignalHandler) # Handler for the RPC requests self.RPCresponder = RPCresponder(self.state) # Accept incoming connections in a background thread self.server = SimpleXMLRPCServer((ip,port),logRequests=False,bind_and_activate=False) self.server.server_bind() self.server.server_activate() self.server.register_introspection_functions() self.server.register_instance(self.RPCresponder) t = Thread(target = self._run,name='{0}:{1}'.format(ip,port)) t.daemon = True t.start() def __str__(self): return 'peer {0} - {1}'.format(self.id,self.name) def _run(self): """ Accept incoming connection till exit """ self.server.serve_forever() def _getIP(self): s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.connect(('google.com',80)) ip = s.getsockname()[0] s.close() return ip def kill(self): self.log.red( self,'=> killed') self.RPCresponder.kill() def revive(self): self.log.green( self,'=> revived') self.RPCresponder.revive() def setUnreliable(self): self.log.red( self,'=> unreliable') self.RPCresponder.setUnreliable() def setReliable(self): self.log.green( self,'=> reliable') self.RPCresponder.setReliable() def addPeer(self,ip,port): """ Add a new peer """ self.state.addPeer(ip,port) def getStrokes(self): return self.state.getStrokes() def thaw(self, sid): self.state.thaw(sid) def freeze(self, sid): self.state.freeze(sid)
def setup_hook(): _excepthook = sys.excepthook def hook(exctype, value, traceback): print(exctype, value, traceback) _excepthook(exctype, value, traceback) sys.exit(1) sys.excepthook = hook if __name__ == '__main__': setup_hook() QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) app = QApplication(sys.argv) app.setWindowIcon(QIcon(':/icon/img/logo.png')) w = MainWindow() cp = QDesktopWidget().availableGeometry().center() qr = w.frameGeometry() qr.moveCenter(cp) w.move(qr.topLeft()) w.show() w.tabs_container.setCurrentIndex(0) try: sys.exit(app.exec_()) except: pass
# Joao Victor Fagundes # Salomao Rodrigues Jacinto # INE5421 - Trablho Prático II Junho 2018 import sys from ui.main_window import MainWindow from PyQt5.QtWidgets import QApplication if __name__ == "__main__": app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_())
if __name__ == '__main__': print('Reading databases...') servers_db = ServerDatabase() abnormal_db = AbnormalDatabase() hot_dot_db = HotDotDatabase() icon_db = IconDatabase() npc_db = NpcDatabase() skill_db = SkillDatabase() opcodes_db = OpcodesDatabase() tracker = Tracker() app = wx.App() ui = MainWindow() msg_handler = MessagesHandler() c_splitter = BlockSplitter(MessageDirection(1), msg_handler.messages) s_splitter = BlockSplitter(MessageDirection(2), msg_handler.messages) con_handler = ConnectionHandler(c_splitter, s_splitter) sniffer = Sniffer(con_handler.queue) msg_handler.start() c_splitter.start() s_splitter.start() con_handler.start() sniffer.start() app.MainLoop() # hold in UI loop
from PyQt5.Qt import QApplication from PyQt5.QtWidgets import QMessageBox from ui.main_window import MainWindow from core.session import Session from core.util import Utility import sys import logging CONFIG_FILE_PATH = "config/config.conf" if __name__ == '__main__': app = QApplication(sys.argv) logging.basicConfig(level=logging.INFO) try: session = Session(CONFIG_FILE_PATH) except ValueError as e: QMessageBox.warning(None, "Error", "Error parsing config file...") sys.exit(1) except (OSError, IOError) as e: QMessageBox.warning(None, "Error", "Couldn't open config file") sys.exit(1) main_window = MainWindow(app.desktop(), session) main_window.show() sys.exit(app.exec_())
def write(self, message): os.write(self.fd, message.encode()) def flush(self): pass if __name__ == '__main__': app = QApplication(sys.argv) window = QMainWindow() # capture file descriptors, responsible for stderr and stdout and pass them to console for logging stdout_descriptor = sys.stdout.fileno() new_stdout, in_write = os.pipe() os.dup2(in_write, stdout_descriptor) sys.stdout = FDWrapper(in_write) dark = '--dark' in sys.argv if dark: stylesheet = load_stylesheet_pyqt5() window.setStyleSheet(stylesheet) main_ui = MainWindow(window, new_stdout, dark) main_ui.setupUi(window) main_ui.initialize() print('Ready.') window.show() sys.exit(app.exec_())
def main(): app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_())
from PySide2.QtGui import QIcon # custom style from pdi.widgets.qstyle import darkstyle # main window from ui.main_window import MainWindow # logger utility from util.setup_log import setupLogger if __name__ == "__main__": os.chdir(os.path.dirname(os.path.abspath(os.path.join(__file__, "../")))) print(os.getcwd()) print("AAA") # アプリケーション作成 app = QApplication(sys.argv) # app.setWindowIcon(QIcon("icon.png")) # オブジェクト作成 window = MainWindow(sys.argv) # MainWindowの表示 window.show() window.resize(1200, 800) ret = app.exec_() print(ret) sys.exit(ret)
#!/usr/bin/env python # -*- coding: utf-8 -*- from PyQt4 import QtCore, QtGui from ui.main_window import MainWindow if __name__ == '__main__': import sys app = QtGui.QApplication(sys.argv) w = MainWindow() w.show() sys.exit(app.exec_())
from ui.main_window import MainWindow if __name__ == "__main__": MainWindow()
ga_solver = GASolver(n_population=8) final_state = ga_solver.solve() final_state.print_chessboard() print(final_state.get_attacking_count()) print(ga_solver.get_running_time(), ga_solver.get_expanded_count(), ga_solver.get_cost()) csp = CSPSolver() csp.solve(state) print("Number steps to the final solution =", csp.get_cost()) csp.final_sol.print_chessboard() print("Expanded node count =", csp.get_expanded_count()) print("Execution time in milliseconds =", csp.get_running_time()) # hill = HillClimbingSolver() # hill.solve(ChessboardStateNode(state), 'rr') # print("Number steps to the final solution =", hill.get_cost()) # hill.get_final_solution().print_chessboard() # print("Number of attacks in the final solution =", hill.conflictions_count) # print("Expanded node count =", hill.get_expanded_count()) # print("Execution time in milliseconds =", hill.get_running_time()) # # print(len(state.neighbors())); # GUI app = QtWidgets.QApplication(sys.argv) main = MainWindow() main.setWindowTitle("8 Queens") main.show() sys.exit(app.exec_())
import sys from PySide.QtGui import QApplication from ui.main_window import MainWindow APP_NAME = 'Dreamer' class DreamerApp(QApplication): def __init__(self, *args, **kwargs): QApplication.__init__(self, *args, **kwargs) self.setApplicationName(APP_NAME) app = DreamerApp(sys.argv) if __name__ == "__main__": window = MainWindow() window.setWindowTitle(APP_NAME) window.show() return_code = app.exec_() sys.exit(return_code)
import sys from ui.main_window import MainWindow from PyQt5 import QtWidgets if __name__ == "__main__": app = QtWidgets.QApplication(sys.argv) main = MainWindow() main.show() sys.exit(app.exec_())
import gi gi.require_version('Gtk', '3.0') gi.require_version('GtkSource', '3.0') from gi.repository import Gtk from graph.source_graph import SourceGraph import logging import os.path import signal import sys from ui.main_window import MainWindow from workspace import Workspace if __name__ == '__main__': logging.basicConfig(level=logging.INFO) signal.signal(signal.SIGINT, signal.SIG_DFL) ws_dir = '.workspace' if len(sys.argv) == 2: ws_dir = sys.argv[1] if not os.path.isdir(ws_dir): logging.warn( 'Workspace doesn\'t exist: {}'.format(ws_dir)) workspace = Workspace(ws_dir) src_graph = SourceGraph(workspace) win = MainWindow(workspace, src_graph) win.connect("delete-event", Gtk.main_quit) win.show_all() Gtk.main()
#!/usr/bin/python3 import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk, GdkPixbuf, GObject, GLib import os from ui.main_window import MainWindow from ui.view_service_window import ViewServiceWindow log_viewer = MainWindow() Gtk.main()
#!/usr/bin/env python3 # Make sure to find pyVFRendering, nanogui and ovf if manually built # This is only needed if you did not install the package # # import sys # import os # pyVFRenderingDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "VFRendering/build/Release")) # sys.path.insert(0, pyVFRenderingDir) # nanoguiDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "nanogui/build/Release/python")) # sys.path.insert(0, nanoguiDir) # nanoguiDir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), "ovf/python")) # sys.path.insert(0, nanoguiDir) import nanogui import gc from ui.main_window import MainWindow if __name__ == '__main__': nanogui.init() win = MainWindow(800, 600) win.setVisible(True) nanogui.mainloop(refresh=1000) del win gc.collect nanogui.shutdown()
# -*- coding: UTF-8 -*- ''' Created on 28/09/2010 @author: rodrigo ''' import logging import sip sip.setapi('QString', 2) sip.setapi('QVariant', 2) logging.basicConfig(level=logging.DEBUG) logging.getLogger(__name__).debug("Inicializando") if __name__ == '__main__': from PyQt4.QtGui import QApplication from ui.main_window import MainWindow import sys import core core.models.initDB() app = QApplication(sys.argv) window = MainWindow() window.show() app.exec_()
from PyQt5.QtWidgets import QApplication from application_service.get_map_uc import GetMapUseCase from serveces.YandexMapAdapter import YandexMapAdapter from ui.main_window import MainWindow adapter = YandexMapAdapter() use_case = GetMapUseCase(adapter) app = QApplication([]) win = MainWindow(use_case) win.show() app.exec()
import sys import argparse from PyQt5.QtWidgets import QApplication from ui.main_window import MainWindow def parse_arguments(): parser = argparse.ArgumentParser("Argument parser for decision system") parser.add_argument("-p", "--path", help="Path to the file with decision graph to import", type=str) return parser.parse_args() if __name__ == '__main__': args = parse_arguments() app = QApplication([]) main_window = MainWindow() if args.path: main_window.import_from_path(args.path) pass sys.exit(app.exec_())