pytact.visualisation_webserver

  1from dataclasses import asdict
  2from pathlib import Path
  3import argparse
  4import pkg_resources
  5import inflection
  6from functools import partial
  7
  8from pytact.data_reader import data_reader
  9from pytact.graph_visualize_browse import (
 10    GraphVisualizationData, GraphVisualizator, UrlMaker, Settings, GraphVisualizationOutput)
 11
 12import capnp
 13import pytact.graph_api_capnp as graph_api_capnp
 14
 15from sanic import Sanic
 16from sanic_ext import validate
 17from sanic.worker.loader import AppLoader
 18
 19def post_process(output: GraphVisualizationOutput, settings: Settings):
 20    result = asdict(output)
 21    result['settings'] = settings
 22    result['edge_labels'] = [(v, inflection.camelize(name)) for (name, v) in
 23                             graph_api_capnp.EdgeClassification.schema.enumerants.items()]
 24    result['node_labels'] = [(v, inflection.camelize(name)) for (v, name) in
 25                             enumerate(list(graph_api_capnp.Graph.Node.Label.schema.union_fields))]
 26    return result
 27
 28def create_app(dataset_path: Path) -> Sanic:
 29    app = Sanic("graph-visualizer")
 30    app.config.TEMPLATING_PATH_TO_TEMPLATES = pkg_resources.resource_filename('pytact', 'templates/')
 31
 32    @app.before_server_start
 33    async def setup_dataset(app):
 34        app.ctx.data_ctx = data_reader(dataset_path)
 35        app.ctx.gvd = GraphVisualizationData(app.ctx.data_ctx.__enter__())
 36    @app.after_server_stop
 37    async def teardown_dataset(app):
 38        del app.ctx.gvd
 39        app.ctx.data_ctx.__exit__(None, None, None)
 40        del app.ctx.data_ctx
 41
 42    class SanicUrlMaker(UrlMaker):
 43
 44        def __init__(self, settings: Settings):
 45            self.query = {k: v for k, v in asdict(settings).items() if type(v) != bool or v}
 46
 47        def definition(self, fname: Path, defid: int) -> str:
 48            return app.url_for('definition', path=fname.with_suffix(''), defid=defid, **self.query)
 49
 50        def proof(self, fname: Path, defid: int) -> str:
 51            return app.url_for('proof', path=fname.with_suffix(''), defid=defid, **self.query)
 52
 53        def outcome(self, fname: Path, defid: int, stepi: int, outcomei: int) -> str:
 54            return app.url_for('outcome', path=fname.with_suffix(''),
 55                            defid=defid, stepi=stepi, outcomei=outcomei, **self.query)
 56
 57        def global_context(self, fname: Path) -> str:
 58            return app.url_for('global_context', path=fname.with_suffix(''), **self.query)
 59
 60        def folder(self, path: Path) -> str:
 61            return app.url_for('folder', path=path, **self.query)
 62
 63        def root_folder(self) -> str:
 64            return app.url_for('root_folder', **self.query)
 65
 66    @app.get('/<path:path>/definition/<defid:int>/proof/step/<stepi:int>/outcome/<outcomei:int>')
 67    @validate(query=Settings)
 68    @app.ext.template("visualizer.html")
 69    async def outcome(request, path: str, defid: str, stepi: str, outcomei: str, query: Settings):
 70        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
 71        return post_process(gv.outcome(Path(path).with_suffix(".bin"), int(defid), int(stepi), int(outcomei)), query)
 72
 73    @app.get('/<path:path>/definition/<defid:int>/proof')
 74    @validate(query=Settings)
 75    @app.ext.template("visualizer.html")
 76    async def proof(request, path: str, defid: str, query: Settings):
 77        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
 78        return post_process(gv.proof(Path(path).with_suffix(".bin"), int(defid)), query)
 79
 80    @app.get('/<path:path>/definition/<defid:int>')
 81    @validate(query=Settings)
 82    @app.ext.template("visualizer.html")
 83    async def definition(request, path: str, defid: str, query: Settings):
 84        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
 85        return post_process(gv.definition(Path(path).with_suffix(".bin"), int(defid)), query)
 86
 87    @app.get('/<path:path>/context')
 88    @validate(query=Settings)
 89    @app.ext.template("visualizer.html")
 90    async def global_context(request, path: str, query: Settings):
 91        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
 92        return post_process(gv.global_context(Path(path).with_suffix(".bin")), query)
 93
 94    @app.get('/<path:path>')
 95    @validate(query=Settings)
 96    @app.ext.template("visualizer.html")
 97    async def folder(request, path: str, query: Settings):
 98        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
 99        return post_process(gv.folder(Path(path)), query)
100
101    @app.get('/')
102    @validate(query=Settings)
103    @app.ext.template("visualizer.html")
104    async def root_folder(request, query: Settings):
105        gv = GraphVisualizator(app.ctx.gvd, SanicUrlMaker(query), query)
106        return post_process(gv.folder(Path()), query)
107
108    return app
109
110def main():
111
112    parser = argparse.ArgumentParser(
113        description = 'Start an interactive server that visualizes a dataset',
114        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
115
116    parser.add_argument('dataset',
117                        type=str,
118                        help=('The location of the dataset to visualize. ' +
119                              'Either a dataset directory, or a SquashFS image, ' +
120                              'which will be automatically mounted.'))
121    parser.add_argument('--port',
122                        type=int,
123                        default=8080,
124                        help='the port where the webserver should listen')
125    parser.add_argument('--hostname',
126                       type=str,
127                       default='0.0.0.0',
128                       help='the ip or domain of the hosting machine')
129    parser.add_argument('--dev',
130                        action='store_true',
131                        help='run the server in development mode')
132    group = parser.add_mutually_exclusive_group()
133    group.add_argument('--fast', action='store_true', default=False,
134                       help='Run the server with an optimal number of worker')
135    group.add_argument('--workers', type=int, default=1,
136                       help='The number of workers to use')
137
138    args = parser.parse_args()
139
140    dataset_path = Path(args.dataset).resolve()
141
142    loader = AppLoader(factory=partial(create_app, dataset_path))
143    app = loader.load()
144    app.prepare(host=args.hostname, port=args.port, dev=args.dev, fast=args.fast, workers=args.workers)
145    Sanic.serve(primary=app, app_loader=loader)
146
147if __name__ == '__main__':
148    main()