def launch(self, inline=None, inbrowser=None, share=False, debug=False, auth=None, auth_message=None, private_endpoint=None, prevent_thread_lock=False): """ Parameters: inline (bool): whether to display in the interface inline on python notebooks. inbrowser (bool): whether to automatically launch the interface in a new tab on the default browser. share (bool): whether to create a publicly shareable link from your computer for the interface. debug (bool): if True, and the interface was launched from Google Colab, prints the errors in the cell output. auth (Callable, Union[Tuple[str, str], List[Tuple[str, str]]]): If provided, username and password (or list of username-password tuples) required to access interface. Can also provide function that takes username and password and return True if valid login. auth_message (str): If provided, HTML message provided on login page. Returns: app (flask.Flask): Flask app object path_to_local_server (str): Locally accessible link share_url (str): Publicly accessible link (if share=True) """ # Alert user if a more recent version of the library exists utils.version_check() # Set up local flask server config = self.get_config_file() self.config = config if auth and not callable(auth) and not isinstance( auth[0], tuple) and not isinstance(auth[0], list): auth = [auth] self.auth = auth self.auth_message = auth_message # Request key for encryption if self.encrypt: self.encryption_key = encryptor.get_key( getpass("Enter key for encryption: ")) # Launch local flask server server_port, app, thread = networking.start_server( self, self.server_name, self.server_port, self.auth) path_to_local_server = "http://{}:{}/".format(self.server_name, server_port) self.local_url = path_to_local_server self.server_port = server_port self.status = "RUNNING" self.server = app # Count number of launches launch_counter() # If running in a colab or not able to access localhost, automatically create a shareable link is_colab = utils.colab_check() if is_colab or not (networking.url_ok(path_to_local_server)): share = True if is_colab: if debug: print(strings.en["COLAB_DEBUG_TRUE"]) else: print(strings.en["COLAB_DEBUG_FALSE"]) else: print(strings.en["RUNNING_LOCALLY"].format(path_to_local_server)) if is_colab and self.requires_permissions: print(strings.en["MEDIA_PERMISSIONS_IN_COLAB"]) if private_endpoint is not None: share = True # Set up shareable link self.share = share if share: if not private_endpoint: print(strings.en["SHARE_LINK_MESSAGE"]) try: share_url = networking.setup_tunnel(server_port, private_endpoint) self.share_url = share_url print(strings.en["SHARE_LINK_DISPLAY"].format(share_url)) except RuntimeError: send_error_analytics(self.analytics_enabled) share_url = None else: print(strings.en["PUBLIC_SHARE_TRUE"]) share_url = None # Open a browser tab with the interface. if inbrowser: if share: webbrowser.open(share_url) else: webbrowser.open(path_to_local_server) # Check if running in a Python notebook in which case, display inline if inline is None: inline = utils.ipython_check() if inline: try: from IPython.display import IFrame, display # Embed the remote interface page if on google colab; otherwise, embed the local page. print(strings.en["INLINE_DISPLAY_BELOW"]) if share: while not networking.url_ok(share_url): time.sleep(1) display( IFrame(share_url, width=self.width, height=self.height)) else: display( IFrame(path_to_local_server, width=self.width, height=self.height)) except ImportError: pass # IPython is not available so does not print inline. send_launch_analytics(analytics_enabled=self.analytics_enabled, inbrowser=inbrowser, is_colab=is_colab, share=share, share_url=share_url) show_tip(self) # Run server perpetually under certain circumstances if debug or int(os.getenv('GRADIO_DEBUG', 0)) == 1: while True: sys.stdout.flush() time.sleep(0.1) is_in_interactive_mode = bool( getattr(sys, 'ps1', sys.flags.interactive)) if not prevent_thread_lock and not is_in_interactive_mode: self.run_until_interrupted(thread, path_to_local_server) return app, path_to_local_server, share_url
def launch( self, inline: bool = None, inbrowser: bool = None, share: bool = False, debug: bool = False, auth: Optional[Callable | Tuple[str, str] | List[Tuple[str, str]]] = None, auth_message: Optional[str] = None, private_endpoint: Optional[str] = None, prevent_thread_lock: bool = False, show_error: bool = True, server_name: Optional[str] = None, server_port: Optional[int] = None, show_tips: bool = False, enable_queue: bool = False, height: int = 500, width: int = 900, encrypt: bool = False, favicon_path: Optional[str] = None, ssl_keyfile: Optional[str] = None, ssl_certfile: Optional[str] = None, ssl_keyfile_password: Optional[str] = None, ) -> Tuple[FastAPI, str, str]: """ Launches the webserver that serves the UI for the interface. Parameters: inline (bool): whether to display in the interface inline on python notebooks. inbrowser (bool): whether to automatically launch the interface in a new tab on the default browser. share (bool): whether to create a publicly shareable link from your computer for the interface. debug (bool): if True, and the interface was launched from Google Colab, prints the errors in the cell output. auth (Callable, Union[Tuple[str, str], List[Tuple[str, str]]]): If provided, username and password (or list of username-password tuples) required to access interface. Can also provide function that takes username and password and returns True if valid login. auth_message (str): If provided, HTML message provided on login page. private_endpoint (str): If provided, the public URL of the interface will be this endpoint (should generally be unchanged). prevent_thread_lock (bool): If True, the interface will block the main thread while the server is running. show_error (bool): If True, any errors in the interface will be printed in the browser console log server_port (int): will start gradio app on this port (if available). Can be set by environment variable GRADIO_SERVER_PORT. server_name (str): to make app accessible on local network, set this to "0.0.0.0". Can be set by environment variable GRADIO_SERVER_NAME. show_tips (bool): if True, will occasionally show tips about new Gradio features enable_queue (bool): if True, inference requests will be served through a queue instead of with parallel threads. Required for longer inference times (> 1min) to prevent timeout. width (int): The width in pixels of the iframe element containing the interface (used if inline=True) height (int): The height in pixels of the iframe element containing the interface (used if inline=True) encrypt (bool): If True, flagged data will be encrypted by key provided by creator at launch favicon_path (str): If a path to a file (.png, .gif, or .ico) is provided, it will be used as the favicon for the web page. ssl_keyfile (str): If a path to a file is provided, will use this as the private key file to create a local server running on https. ssl_certfile (str): If a path to a file is provided, will use this as the signed certificate for https. Needs to be provided if ssl_keyfile is provided. ssl_keyfile_password (str): If a password is provided, will use this with the ssl certificate for https. Returns: app (FastAPI): FastAPI app object that is running the demo local_url (str): Locally accessible link to the demo share_url (str): Publicly accessible link to the demo (if share=True, otherwise None) """ self.config = self.get_config_file() if (auth and not callable(auth) and not isinstance(auth[0], tuple) and not isinstance(auth[0], list)): auth = [auth] self.auth = auth self.auth_message = auth_message self.show_tips = show_tips self.show_error = show_error self.height = height self.width = width self.favicon_path = favicon_path if hasattr(self, "encrypt") and self.encrypt is None: self.encrypt = encrypt if hasattr(self, "encrypt") and self.encrypt: self.encryption_key = encryptor.get_key( getpass.getpass("Enter key for encryption: ")) if hasattr(self, "enable_queue") and self.enable_queue is None: self.enable_queue = enable_queue config = self.get_config_file() self.config = config if self.is_running: self.server_app.launchable = self print( "Rerunning server... use `close()` to stop if you need to change `launch()` parameters.\n----" ) else: server_port, path_to_local_server, app, server = networking.start_server( self, server_name, server_port, ssl_keyfile, ssl_certfile, ssl_keyfile_password, ) self.local_url = path_to_local_server self.server_port = server_port self.server_app = app self.server = server self.is_running = True utils.launch_counter() # If running in a colab or not able to access localhost, # automatically create a shareable link. is_colab = utils.colab_check() if is_colab or not (networking.url_ok(self.local_url)): share = True if is_colab: if debug: print(strings.en["COLAB_DEBUG_TRUE"]) else: print(strings.en["COLAB_DEBUG_FALSE"]) else: print(strings.en["RUNNING_LOCALLY"].format(self.local_url)) if is_colab and self.requires_permissions: print(strings.en["MEDIA_PERMISSIONS_IN_COLAB"]) if private_endpoint is not None: share = True if share: if self.is_space: raise RuntimeError( "Share is not supported when you are in Spaces") try: if self.share_url is None: share_url = networking.setup_tunnel( self.server_port, private_endpoint) self.share_url = share_url print(strings.en["SHARE_LINK_DISPLAY"].format(self.share_url)) if private_endpoint: print(strings.en["PRIVATE_LINK_MESSAGE"]) else: print(strings.en["SHARE_LINK_MESSAGE"]) except RuntimeError: if self.analytics_enabled: utils.error_analytics(self.ip_address, "Not able to set up tunnel") self.share_url = None share = False print(strings.en["COULD_NOT_GET_SHARE_LINK"]) else: print(strings.en["PUBLIC_SHARE_TRUE"]) self.share_url = None self.share = share if inbrowser: link = self.share_url if share else self.local_url webbrowser.open(link) # Check if running in a Python notebook in which case, display inline if inline is None: inline = utils.ipython_check() and (auth is None) if inline: if auth is not None: print("Warning: authentication is not supported inline. Please" "click the link to access the interface in a new tab.") try: from IPython.display import IFrame, display # type: ignore if share: while not networking.url_ok(self.share_url): time.sleep(1) display( IFrame(self.share_url, width=self.width, height=self.height)) else: display( IFrame(self.local_url, width=self.width, height=self.height)) except ImportError: pass data = { "launch_method": "browser" if inbrowser else "inline", "is_google_colab": is_colab, "is_sharing_on": share, "share_url": self.share_url, "ip_address": self.ip_address, "enable_queue": self.enable_queue, "show_tips": self.show_tips, "server_name": server_name, "server_port": server_port, "is_spaces": self.is_space, "mode": self.mode, } if hasattr(self, "analytics_enabled") and self.analytics_enabled: utils.launch_analytics(data) utils.show_tip(self) # Block main thread if debug==True if debug or int(os.getenv("GRADIO_DEBUG", 0)) == 1: self.block_thread() # Block main thread if running in a script to stop script from exiting is_in_interactive_mode = bool( getattr(sys, "ps1", sys.flags.interactive)) if not prevent_thread_lock and not is_in_interactive_mode: self.block_thread() return self.server_app, self.local_url, self.share_url
def test_diff_pass(self): key1 = encryptor.get_key("test") key2 = encryptor.get_key("diff_test") self.assertNotEqual(key1, key2)
def test_same_pass(self): key = encryptor.get_key("test") data, _ = processing_utils.decode_base64_to_binary(BASE64_IMAGE) encrypted_data = encryptor.encrypt(key, data) decrypted_data = encryptor.decrypt(key, encrypted_data) self.assertEqual(data, decrypted_data)
def test_same_pass(self): key1 = encryptor.get_key("test") key2 = encryptor.get_key("test") self.assertEqual(key1, key2)