adapt qiime tools view to launch q2view locally (#351)

This enables viewing of provenance, metadata, and citations locally (as opposed to only via https://view.qiime2.org) and is a first step toward additional ways to view and interact with data provenance graphs through other interfaces.

Author: Oddant1

.gitignore

@@ -76,3 +76,5 @@ runinfo
 # Version file from versioningit
 _version.py
 
+# Built vendored view
+q2cli/assets/view

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "q2view"]
+	path = q2view
+	url = https://github.com/qiime2/q2view.git

Makefile

@@ -1,4 +1,4 @@
-.PHONY: all lint test install dev clean distclean
+.PHONY: all lint test init-view-submodule vendor-view install dev clean distclean
 
 PYTHON ?= python
 PREFIX ?= $(CONDA_PREFIX)
@@ -12,20 +12,28 @@ lint:
 test: all
 	QIIMETEST= pytest
 
+vendor-view: all
+	git submodule init && \
+	git submodule update && \
+	cd q2view && \
+	npm install --no-save && \
+	npm run vendor --VENDOR_DIR=../q2cli/assets/view
+
 # install pytest-xdist plugin for the `-n auto` argument.
 mystery-stew: all
 	MYSTERY_STEW= pytest -k mystery_stew -n auto
 
-install: all
+install: vendor-view all
 	$(PYTHON) -m pip install -v . && \
 	mkdir -p $(PREFIX)/etc/conda/activate.d && \
 	cp hooks/50_activate_q2cli_tab_completion.sh $(PREFIX)/etc/conda/activate.d/
 
-dev: all
+dev: vendor-view all
 	pip install -e . && \
 	mkdir -p $(PREFIX)/etc/conda/activate.d && \
 	cp hooks/50_activate_q2cli_tab_completion.sh $(PREFIX)/etc/conda/activate.d/
 
 clean: distclean
+	rm -rf ./q2cli/assets
 
 distclean: ;

q2cli/builtin/tools.py

@@ -511,72 +511,171 @@ def _merge_metadata(paths):
     return metadata
 
 
-@tools.command(short_help='View a QIIME 2 Visualization.',
-               help="Displays a QIIME 2 Visualization until the command "
-                    "exits. To open a QIIME 2 Visualization so it can be "
-                    "used after the command exits, use 'qiime tools extract'.",
+@tools.command(short_help='View a QIIME 2 Result.',
+               help="Displays a QIIME 2 Result until the command exits. To "
+                    "open a QIIME 2 Visualization so it can be used after the "
+                    "command exits, use 'qiime tools extract'.",
                cls=ToolCommand)
-@click.argument('visualization-path', metavar='VISUALIZATION',
+@click.argument('result-path', metavar='RESULT',
                 type=click.Path(file_okay=True, dir_okay=False, readable=True))
-@click.option('--index-extension', required=False, default='html',
-              help='The extension of the index file that should be opened. '
-                   '[default: html]')
-def view(visualization_path, index_extension):
+@click.option('--port', required=False, type=click.IntRange(1024, 65535),
+              default=None, help='The port to serve the webapp on.')
+@click.option('--verbose', is_flag=True,
+              help='Display all GET requests in the terminal.')
+def view(result_path, port, verbose):
+    # Get the abspath to the result
+    result_path = os.path.abspath(result_path)
+
     # Guard headless envs from having to import anything large
     import sys
-    from qiime2 import Visualization
-    from q2cli.util import _load_input
-    from q2cli.core.config import CONFIG
-    if not os.getenv("DISPLAY") and sys.platform != "darwin":
+
+    if not os.getenv('DISPLAY') and sys.platform != 'darwin':
         raise click.UsageError(
-            'Visualization viewing is currently not supported in headless '
-            'environments. You can view Visualizations (and Artifacts) at '
-            'https://view.qiime2.org, or move the Visualization to an '
-            'environment with a display and view it with `qiime tools view`.')
+            'Result viewing is currently not supported in headless '
+            'environments. You can view Results at https://view.qiime2.org, '
+            'or move the Result to an environment with a display and view it '
+            'with `qiime tools view`.')
 
-    if index_extension.startswith('.'):
-        index_extension = index_extension[1:]
+    import signal
+    import random
+    import tempfile
+    import threading
+    import http.server
+    import contextlib
 
-    _, visualization = _load_input(visualization_path, view=True)[0]
-    if not isinstance(visualization, Visualization):
-        raise click.BadParameter(
-            '%s is not a QIIME 2 Visualization. Only QIIME 2 Visualizations '
-            'can be viewed.' % visualization_path)
+    from qiime2.sdk import Result
 
-    index_paths = visualization.get_index_paths(relative=False)
+    from q2cli.core.config import CONFIG
 
-    if index_extension not in index_paths:
-        raise click.BadParameter(
-            'No index %s file is present in the archive. Available index '
-            'extensions are: %s' % (index_extension,
-                                    ', '.join(index_paths.keys())))
-    else:
-        index_path = index_paths[index_extension]
-        launch_status = click.launch(index_path)
-        if launch_status != 0:
-            click.echo(CONFIG.cfg_style('error', 'Viewing visualization '
-                                        'failed while attempting to open '
-                                        f'{index_path}'), err=True)
-        else:
-            while True:
-                click.echo(
-                    "Press the 'q' key, Control-C, or Control-D to quit. This "
-                    "view may no longer be accessible or work correctly after "
-                    "quitting.", nl=False)
-                # There is currently a bug in click.getchar where translation
-                # of Control-C and Control-D into KeyboardInterrupt and
-                # EOFError (respectively) does not work on Python 3. The code
-                # here should continue to work as expected when the bug is
-                # fixed in Click.
-                #
-                # https://github.com/pallets/click/issues/583
-                try:
-                    char = click.getchar()
-                    click.echo()
-                    if char in {'q', '\x03', '\x04'}:
-                        break
-                except (KeyboardInterrupt, EOFError):
-                    break
+    # Load and extract result
+    result = Result.load(result_path)
+
+    extracted_path = os.path.join(tempfile.gettempdir(), str(result.uuid))
+    if not os.path.exists(extracted_path):
+        result.extract(result_path, tempfile.gettempdir())
+
+    # This ought to look like a session id generated by normal view
+    CHAR_SET = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    SESSION_LEN = 11
+    session = ''.join(random.choice(CHAR_SET) for i in range(SESSION_LEN))
+
+    # Start server
+    class Handler(http.server.SimpleHTTPRequestHandler):
+        def do_GET(self):
+            # Redirect the output from these requests to devnull if not verbose
+            with open(os.devnull, 'w') as devnull:
+                with contextlib.redirect_stderr(
+                        sys.stderr if verbose else devnull):
+                    # Determine if this is a request for the file we are
+                    # supposed to be viewing
+                    if self.path == result_path:
+                        if not os.path.exists(self.path):
+                            self.send_error(404)
+                        else:
+                            self.send_response(200)
+                            with open(self.path, 'rb') as file:
+                                self.wfile.write(file.read())
+                    # Determine if this is a request for a file within the
+                    # visualization
+                    elif self.path.startswith(f'/_/{session}/{result.uuid}/'):
+                        file_path = self.path.split(str(result.uuid))[1]
+                        file_path = extracted_path + file_path
+                        file_path = os.path.abspath(file_path)
+
+                        if not os.path.exists(file_path) or \
+                                not file_path.startswith(extracted_path):
+                            self.send_error(404)
+                        else:
+                            self.send_response(200)
+                            self.send_header('Access-Control-Allow-Origin',
+                                             '*')
+                            self.end_headers()
+
+                            with open(file_path, 'rb') as file:
+                                self.wfile.write(file.read())
+                    # Otherwise default to super class. This will respond
+                    # appropriately to requests for assets that are part of the
+                    # vendored view app and will reject any requests for files
+                    # outside the served directory
+                    else:
+                        super().do_GET()
+
+    # Get the path to the packaged vendored view
+    # TODO: This won't work if we start packaging QIIME 2 as a wheel, we will
+    # have to reimplement this used importlib.resources and it may be mildly
+    # annoying to make things work properly. It's hard to tell right now since
+    # we do not use a wheel.
+    # https://docs.python.org/3/library/importlib.resources.html
+    import importlib
+    MODULE_INIT = importlib.import_module('q2cli').__file__
+    MODULE_BASE_DIR = os.path.abspath(os.path.dirname(MODULE_INIT))
+    VENDOR_PATH = os.path.join(MODULE_BASE_DIR, 'assets', 'view')
+
+    # Set up the server socket
+    import socket
+
+    server_socket = socket.socket()
+    # If port is None then slap a 0 into here to get a free port
+    server_socket.bind(('localhost', 0 if port is None else port))
+    # Get the port off the opened socket, if a port was passed, this will set
+    # the port to itself no harm done. If no port was passed, this will get the
+    # open port that .bind found.
+    port = server_socket.getsockname()[1]
+
+    # Start up the server
+    server = http.server.HTTPServer(
+        ('localhost', port), lambda *_: Handler(*_, directory=VENDOR_PATH),
+        bind_and_activate=False)
+    server.socket = server_socket
+
+    # Don't listen until the server is already going
+    server_socket.listen(0)
+    click.echo(f'Agent started on port: {port}')
+
+    # Stop server on termination of main thread
+    def stop():
+        server.shutdown()
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, stop)
+
+    # Start the server in a new thread
+    thread = threading.Thread(target=server.serve_forever)
+    thread.daemon = True
+    thread.start()
+
+    # Open page on server
+    url = f'http://localhost:{port}?file={result_path}&session={session}'
+    launch_status = click.launch(url)
+    click.echo('Your view should open in your default browser shortly. You '
+               f'may open it manually at the URL: {url}')
+
+    # Yell if there was an error
+    if launch_status != 0:
+        click.echo(
+            CONFIG.cfg_style('error', 'Viewing result failed while attempting '
+                             f'to open {result_path}'),
+            err=True)
+
+    # Wait for shut down request
+    while True:
+        click.echo("Press the 'q' key, Control-C, or Control-D to quit. This "
+                   "view may no longer be accessible or work correctly after "
+                   "quitting.")
+        # There is currently a bug in click.getchar where translation
+        # of Control-C and Control-D into KeyboardInterrupt and
+        # EOFError (respectively) does not work on Python 3. The code
+        # here should continue to work as expected when the bug is
+        # fixed in Click.
+        #
+        # https://github.com/pallets/click/issues/583
+        try:
+            char = click.getchar()
+            click.echo()
+            if char in {'q', '\x03', '\x04'}:
+                break
+        except (KeyboardInterrupt, EOFError):
+            break
 
 
 @tools.command(short_help="Extract a QIIME 2 Artifact or Visualization "