def main(): # pylint: disable=import-outside-toplevel api = Api() api.window = webview.create_window(f"Wild Bits {USER_VERSION}", url=f"{EXEC_DIR}/assets/index.html", js_api=api) gui: str = "" if system() == "Windows": try: # fmt: off from cefpython3 import cefpython del cefpython gui = "cef" # fmt: on except ImportError: pass elif system() == "Linux": try: # fmt: off from PyQt5 import QtWebEngine del QtWebEngine gui = "qt" # fmt: on except ImportError: gui = "gtk" webview.start(debug=True, http_server=gui == "", gui=gui, func=api.handle_file)
def start_server(): retries = 0 server_started = False while not server_started and retries < 100: try: retries += 1 list_serial_ports() port = get_port() server_address = ("127.0.0.1", port) httpd = ThreadedHTTPServer(server_address, appRequestHandler) threading.Thread(target=httpd.serve_forever).start() print(("Server running on port " + str(port))) server_started = True except Exception as e: print("Exception while starting server: " + str(e)) pass webview.create_window('OpenModem Configuration', 'http://localhost:' + str(port) + '/', width=575, height=600) webview.start() os._exit(0)
def imgdisplay_main(): imgdisplay_log.debug('Imgdisplay') fm = threading.Thread(name='filemon', target=mon.filemonmain, daemon=True) fm.start() kwargs = {'host': 'localhost', 'port': 5432, 'width': 768, 'height': 432} t = threading.Thread(name='start_server', target=start_server, daemon=True, kwargs=kwargs) t.start() global window window = webview.create_window( "Live Image View", "http://127.0.0.1:{port}".format(port=kwargs['port']), height=kwargs['height'], width=kwargs['width'], fullscreen=False, confirm_close=True) try: imgdisplay_log.debug('WebviewStart') webview.start() except Exception: # logging.exception provides: (1) exception type (2) error message and (3) stacktrace imgdisplay_log.exception("Unhandled Exception from Main!") except KeyboardInterrupt: imgdisplay_log.error("Live View & File Monitoring will be halted!") sys.exit()
def __init__(self): mon = get_monitors()[0] window = webview.create_window('', self.url, width=mon.width, height=mon.height) webview.start(self.manage, window, gui='cef')
def run(self): # Webview needs to be run in the MainThread. # Prepare for version 2.3 before calling create_window(), which might block forever. self.display_window = webview # Since webview.create_window might take exclusive and permanent lock on the main thread, # we need to start this wait_load function before we start webview itself. if "webview_ready" in dir(webview): threading.Thread( target=lambda: (webview.webview_ready(), load_idle()) ).start() window = webview.create_window( title="Jellyfin MPV Shim Mirror", js_api=helpers, fullscreen=True ) if window is not None: # It returned a Window object instead of blocking, we're running on 3.2 (or compatible) self.display_window = window self.webview = window # 3.2's .loaded event runs every time a new DOM is loaded as well, so not suitable for this purpose # However, 3.2's load_html waits for the DOM to be ready, so we can completely skip # waiting for that ourselves. threading.Thread(target=load_idle).start() webview.start()
def init(): global crypto key = c.get_val("crypto") crypto = OWLCrypto(key) c.lock() crypto.export() # inf = owlapi.get_sys_info() # hello_file = filesystem.FSFile("/README.txt",crypto) # print(hello_file.read()) # c.set_val("cpu.clock_speed",inf["clock_speed"]) print("Mounting FS") filesystem.root = filesystem.FSDirectory("",crypto).create() print("Done") # try: # print(filesystem.root.children[0].path) # except Exception as e: # import traceback # print(traceback.print_exception(*sys.exc_info())) api = JSInterface(key) del key t = threading.Thread(target=sandbox_observer_thread) t.start() signal.signal(signal.SIGINT,await_sigint) window = webview.create_window("OWL-OS", url="./index.html", js_api=api) # window.toggle_fullscreen() webview.start(gui='gtk', debug=True)
def start(link=None, title=title, win_opts=win_opts): _fix_profile() try: import webview except ImportError as e: if e.name != "webview" or "module named" not in e.msg: raise e print( "error: failed to load 'webview' module; " "to use jiten's gui, please install pywebview", file=sys.stderr) sys.exit(1) os.environ["JITEN_GUI_TOKEN"] = webview.token from .app import app opts = dict(debug=bool(app.config.get("DEBUG"))) if system == "Linux" and "PYWEBVIEW_GUI" not in os.environ: opts["gui"] = "qt" def f(): if not link: return base_url = window.get_current_url().rstrip("/") for server in M.SERVERS: if link.startswith(server): url = link.replace(server, base_url, 1).split("#")[0] window.load_url(url) break window = webview.create_window(title, app, **win_opts) webview.start(f, **opts)
def __init__(self): self.window = webview.create_window("ETAP E-Nahtar", self.sablonlar.get("varsayilan"), width=800, height=600, fullscreen=True) webview.start()
def main(): global port url, max_wait = 'localhost', 15 # 15 seconds link = "http://" + url + ":" + str(port) # Starting Server server_thread = Thread(target=run_app, args=(url, port, False)) server_thread.daemon = True server_thread.start() # Waiting for server to load content if is_server_running(url, max_wait): print("Server started") # webbrowser.open(link, new=2) # while server_thread.is_alive(): # time.sleep(0.1) window = webview.create_window("Flair App", link, min_size=(640, 480)) # If you want to inspect element just go to localhost url in browser webview.start(get_user_agent, window) else: print("Server failed to start with a max wait time of " + str(max_wait)) if status is not False: print("Status was " + str(status)) if error is not False: print("Exception was " + str(error)) print("Server has exited")
def main(self, appstore=False): """Run the app.""" # kill possible zombie processes; can't use psutil in py2app context system('lsof -nti:' + str(things3_api.Things3API.port) + ' | xargs kill -9') # Make sure the server shuts down signal.signal(signal.SIGTERM, self.sigterm_handler) print(f"Using database 1: {self.database}") window = webview.create_window( title='KanbanView', url=f'http://{things3_api.Things3API.host}:' + f'{things3_api.Things3API.port}/{self.FILE}', width=1280, height=650, min_size=(1280, 650), frameless=True) if not appstore: window.closed += advertise self.api_thread = Thread(target=self.open_api) try: self.api_thread.start() webview.start() # blocking self.api.flask_context.shutdown() self.api_thread.join() except KeyboardInterrupt: print("Shutting down...") self.api.flask_context.shutdown() self.api_thread.join() sys.exit(0)
def run(mode="production", web_mode=True): print(f"mode: {mode} only_server:") port = find_port() from app.start_server import start, start_web_client start(environment=mode, port=port, is_async=True) sleep(3) if not web_mode: settings = { "background_color": '#333333', "width": 200, "height": 500, "confirm_close": False, "resizable": True, "frameless": False, "easy_drag": False, "on_top": True } def load(window): print("window::load", window) pass # window = Desktop.Instance().new_window(title=TITLE, app=get_app(), settings=settings) from app.start_server import get_app app = get_app() window = webview.create_window(TITLE, app, **settings) webview.start(load, window) else: start_web_client()
def upload_test_file(self, event=None): filename = filedialog.askopenfilename(initialdir=os.getcwd(), title="Select a file You would like to grade: ", filetypes=MY_FILETYPES) GraphicUserInterfaces.uploaded_files.append(filename) GraphicUserInterfaces.current_file = filename with open (filename, 'rt') as file: contents = file.read() processed = preprocessing(contents) generate_wordcloud(processed) generate_spelling_graph(contents) generate_similarities_graph() with open("images/index.html", "wt") as file: file.write( """<p>""" + contents + """</p> <img src='wordcloud.png' style='width:400px;height:300px;'> <img src='spelling_pie.png' style='width:400px;height:300px;'> <img src='spelling_bar.png' style='width:400px;height:300px;'> <img src='similarities_graph.png' style='width:400px;height:300px;'>""") generate_prediction(contents) webview.create_window("""Essay Assessment Dashboard for file{}""".format(GraphicUserInterfaces.current_file), "images/index.html") webview.start(http_server=True)
def main(k_array, data, data_test): data_train = pd.read_csv(data) data_test = pd.read_csv(data_test) for i in k_array: KnnVisualisation2dWithTestSet(data_train, data_test, i).visualisation() webview.start()
def start_webview(): window = webview.create_window('Howdimain', url='https://www.howdiweb.nl', confirm_close=True, width=1000, height=600) webview.start() window.closed = os._exit(0)
def render_window(title,content): """ Renders the content in a webview window. :param title: Title of the window :param content: html content to render """ webview.create_window(title=title, html=content) webview.start()
def main(): # Try to run setup the marker in the current directory, but this # might fail if command line args are not specified. Don't do # anything here, user will be prompted to pick dir in UI. setupMarker() window = webview.create_window('Marker', app, width=1280, height=800, easy_drag=True) webview.start()
def show_floorplan(input_pipe): prepare_prediction() window = webview.create_window('Floorplan', html='Loading...', width=800, height=700, frameless=False) webview.start(load_html, (window, input_pipe))
def start_window(): global p_gui, p_http_server, p_debug, window, window_is_alive window_is_alive = True wv.start(viewport.bg_tasks.background_thread, window, gui=p_gui, debug=p_debug, http_server=p_http_server)
def FIND_ARTICLE(self): # To pass custom settings to CEF, import and update settings dict from webview.platforms.cef import settings settings.update({ 'persist_session_cookies': True, }) webview.create_window('CEF Example', 'https://en.wikipedia.org/wiki/Special:Random') webview.start(gui='cef')
def start_webpage(): log.debug("Starting Webpage") webview.create_window("", HTML_FILES, js_api=api, width=WINDOW_WIDTH, height=WINDOW_HEIGHT, frameless=True) webview.start(gui='gtk')
def __init__(self): self.dir = './views/static/' file_path = self.dir + 'page.html' self.width = 800 self.hegiht = 600 webview.create_window('References', file_path, width=self.width, height=self.hegiht) webview.start()
def app(): global isPackaged window = webview.create_window('PrivacyFlash Pro', url='./interface/index.html', background_color='#f8f9fa', width=1366, height=768, text_select=True) window._js_api = Api(window) webview.start(http_server=True, debug=False if isPackaged else True)
def _main_pywebview(): PORT = 21934 webview = threading.Thread(target=start_server, args=(PORT, ), daemon=True) webview.start() #webview.join() time.sleep(0.3) start_py_web_view(PORT)
def start(self): api = Api() self.window = webview.create_window( "Магазин приложений", "../front/dist/index.html", js_api=api, width=self.width, height=self.height, resizable=self.resizable, ) webview.start(gui='cef', http_server=False, debug=True)
def launch(): """ Launch a pywebview and bottle powered web-based UI for ArgDB """ thread = threading.Thread(target=run, kwargs=dict(host='localhost', port=8080)) thread.daemon = True thread.start() webview.create_window("ArgDB", "http://localhost:8080", width=800, height=600, resizable=False) webview.start()
def serve_forever(self): try: import webview except ImportError: raise ImportError('PyWebView is missing. Please install it by:\n ' 'pip install pywebview\n ' 'more info at https://github.com/r0x0r/pywebview') else: Server.start(self) webview.create_window(self.title, self.address, **self._application_conf) webview.start() Server.stop(self)
def main(): global window config = Config() api = Api(config) window = webview.create_window('PogUI', INDEX_HTML, js_api=api, min_size=(600, 450), text_select=True) window.closed += on_closed webview.start(load_page_data, window, debug=config.get('debug', False))
def main(): logger.info(f'\n#\n# Booting Kanmail {get_version()}\n#') init_window_hacks() boot() server_thread = Thread(name='Server', target=run_server) server_thread.daemon = True server_thread.start() run_thread(validate_or_remove_license) run_thread(run_cache_cleanup_later) # Ensure the webserver is up & running by polling it waits = 0 while waits < 10: try: response = requests.get( f'http://{SERVER_HOST}:{server.get_port()}/ping') response.raise_for_status() except requests.RequestException as e: logger.warning(f'Waiting for main window: {e}') sleep(0.1 * waits) waits += 1 else: break else: logger.critical('Webserver did not start properly!') sys.exit(2) create_window( unique_key='main', **get_window_settings(), ) # Let's hope this thread doesn't fail! monitor_thread = Thread( name='Thread monitor', target=monitor_threads, args=(server_thread, ), ) monitor_thread.daemon = True monitor_thread.start() if DEBUG: sleep(1) # give webpack a second to start listening # Start the GUI - this will block until the main window is destroyed webview.start(gui=GUI_LIB, debug=DEBUG) # Main window closed, cleanup/exit sys.exit()
def main(): global sync print(sys.argv) url = "index.html" if len(sys.argv) > 1: url = sys.argv[1] print("main thread id:", threading.get_ident()) data_dir = appdirs.user_data_dir(APPNAME) if not os.path.exists(data_dir): os.mkdir(data_dir) setting = read_setting_db() if not setting: setting = { "workspace": os.path.join(Path.home(), "gitCloud"), "interval": config.SYNC_INTERVAL } print("setting:", setting) excludesFile = os.path.join(appdirs.user_data_dir(APPNAME), ".gitignore") createExcludesFile(excludesFile) print("excludesFile:", excludesFile) workspace = setting["workspace"] if not os.path.exists(workspace): os.mkdir(workspace) if os.path.isabs(config.GIT): path = os.path.dirname(config.GIT) env_path = os.getenv("PATH") if env_path: env_path = env_path + ":" + path else: env_path = path set_env_path(env_path) api = Api(setting) repos = [repo.copy() for repo in api.repos] sync = Sync(repos, event_q, setting["interval"], excludesFile) window = webview.create_window('gitCloud', url, width=400, height=680, js_api=api) api.window = window api.start() sync.start(sync_q, workspace) webview.start(debug=config.DEBUG)
def set_up(): logger.debug('Starting server') t = Thread(target=run_server) t.daemon = True t.start() logger.debug('Checking server') while not url_ok('127.0.0.1', PORT): sleep(1) logger.debug('Server started') logger.debug('Binding on port ' + str(PORT)) create_webview() webview.start(debug=True, gui='qt')