Code format & refactor

Author: blokhin

utils/gui_server.py

@@ -3,8 +3,6 @@
 # Remote entry point for Tilde based on websockets
 # Author: Evgeny Blokhin
 
-# TODO render HTML entirely at the client
-
 import os, sys
 import math
 import time
@@ -23,42 +21,45 @@
 
 from tilde.core.settings import settings, GUI_URL_TPL
 from tilde.core.api import API
-from tilde.parsers import HASH_LENGTH
 from tilde.core.common import html_formula, extract_chemical_symbols, str2html, num2name, generate_cif
 import tilde.core.model as model
-from tilde.berlinium import Async_Connection, add_redirection, eplotter, wrap_cell
+from tilde.berlinium import add_redirection, eplotter, wrap_cell, Async_Connection as Connection
 
 
 logging.basicConfig(level=logging.WARNING)
 
 CURRENT_TITLE = settings['title'] if settings['title'] else 'API version ' + API.version
-DB_TITLE = settings['db']['default_sqlite_db'] if settings['db']['engine'] == 'sqlite' else settings['db']['dbname']
+DB_TITLE = settings['db']['default_sqlite_db'] if settings['db']['engine'] == 'sqlite' else settings['db']['dbname'] + '@' + settings['db']['engine']
 settings['no_parse'] = True
-Tilde = API(settings)
+work = API(settings)
 
 class BerliniumGUIProvider:
     @staticmethod
     def login(req, client_id, db_session):
         data = {
             'title': CURRENT_TITLE,
             'debug_regime': settings['debug_regime'],
-            'version': Tilde.version,
-            'cats': Tilde.hierarchy_groups
+            'version': work.version,
+            'cats': work.hierarchy_groups,
+            'dbsize': work.count(db_session)
         }
         Connection.Clients[client_id].authorized = True
 
         if not req.get('settings'): req['settings'] = {}
 
         # *client-side* settings
-        if req['settings'].get('colnum') not in [50, 100, 250]: req['settings']['colnum'] = 100
-        if type(req['settings'].get('cols')) is not list or not 1 <= len(req['settings'].get('cols')) <= 40: return (None, 'Invalid settings!')
+        if req['settings'].get('colnum') not in [50, 100, 250]:
+            req['settings']['colnum'] = 100
+
+        if type(req['settings'].get('cols')) is not list or not 1 <= len(req['settings'].get('cols')) <= 40:
+            return (None, 'Invalid settings!')
 
         for i in ['cols', 'colnum']:
             Connection.Clients[client_id].usettings[i] = req['settings'].get(i)
 
         # all available columns are compiled here and sent to user to select between them
         avcols = []
-        for entity in Tilde.hierarchy:
+        for entity in work.hierarchy:
 
             if entity['has_column']:
                 enabled = True if entity['cid'] in req['settings']['cols'] else False
@@ -76,16 +77,25 @@ def browse(req, client_id, db_session):
         data = {'html': '', 'count': 0, 'msg': None}
         error = None
 
-        try: start, sortby = int(req.get('start', 0)), int(req.get('sortby', 0))
-        except ValueError: return (data, 'Sorry, unknown parameters in request')
+        try:
+            start, sortby = int(req.get('start', 0)), int(req.get('sortby', 0))
+        except ValueError:
+            return (data, 'Sorry, unknown parameters in request')
+
         start *= Connection.Clients[client_id].usettings['colnum']
         stop = start + Connection.Clients[client_id].usettings['colnum']
-        if sortby   == 0: sortby = model.Metadata.chemical_formula
-        elif sortby == 1: sortby = model.Metadata.location
-        else: return (data, 'Unknown sorting requested!')
+
+        if sortby   == 0:
+            sortby = model.Metadata.chemical_formula
+        elif sortby == 1:
+            sortby = model.Metadata.location
+        else:
+            return (data, 'Unknown sorting requested!')
 
         if req.get('hashes'):
-            if not isinstance(req['hashes'], list) or len(req['hashes'][0]) != HASH_LENGTH: return (data, 'Invalid request!')
+            if not isinstance(req['hashes'], list) or len(req['hashes'][0]) > 100:
+                return (data, 'Invalid request!')
+
             proposition = req['hashes']
             data['count'] = len(proposition)
             proposition = proposition[start:stop]
@@ -94,16 +104,23 @@ def browse(req, client_id, db_session):
         if req.get('conditions'):
             join_exception = None
             for c in req['conditions']:
-                if not 'cid' in c or not 'min' in c or not 'max' in c: return (data, 'Invalid request!')
-                try: entity = [x for x in Tilde.hierarchy if x['cid'] == int(c['cid'])][0]
-                except IndexError: return (data, 'Invalid category choice!')
-                if not entity['has_slider']: return (data, 'Invalid category choice!')
+                if not 'cid' in c or not 'min' in c or not 'max' in c:
+                    return (data, 'Invalid request!')
+                try:
+                    entity = [x for x in work.hierarchy if x['cid'] == int(c['cid'])][0]
+                except IndexError:
+                    return (data, 'Invalid category choice!')
+                if not entity['has_slider']:
+                    return (data, 'Invalid category choice!')
 
                 cls, attr = entity['has_slider'].split('.')
                 orm_inst = getattr(getattr(model, cls), attr)
                 clauses.append(orm_inst.between(c['min'], c['max']))
-                if cls == 'Lattice': join_exception = cls
-                else: clauses.append(getattr(getattr(model, cls), 'checksum') == model.Calculation.checksum)
+
+                if cls == 'Lattice':
+                    join_exception = cls
+                else:
+                    clauses.append(getattr(getattr(model, cls), 'checksum') == model.Calculation.checksum)
 
             if join_exception == 'Lattice':
                 # Lattice objects require special join clause:
@@ -141,14 +158,14 @@ def browse(req, client_id, db_session):
         if not proposition: return (data, 'Invalid request!')
 
         html_output, res_count = '', 0
-        html_output = '<thead><tr><th class=not-sortable><input type="checkbox" id="d_cb_all"></th>'
-        for entity in Tilde.hierarchy:
+        html_output = '<thead><tr><th class="not-sortable"><input type="checkbox" id="d_cb_all"></th>'
+        for entity in work.hierarchy:
             if entity['has_column'] and entity['cid'] in Connection.Clients[client_id].usettings['cols']:
                 catname = str2html(entity['html']) if entity['html'] else entity['category'][0].upper() + entity['category'][1:]
 
-                plottable = '<input class=sc type=checkbox />' if entity['plottable'] else ''
+                plottable = '<input class="sc" type="checkbox" />' if entity['plottable'] else ''
 
-                html_output += '<th rel=' + str(entity['cid']) + '><span>' + catname + '</span>' + plottable + '</th>'
+                html_output += '<th rel="' + str(entity['cid']) + '"><span>' + catname + '</span>' + plottable + '</th>'
         #if Connection.Clients[client_id].usettings['objects_expand']: html_output += '<th class="not-sortable">More...</th>'
         html_output += '</tr></thead><tbody>'
 
@@ -160,20 +177,20 @@ def browse(req, client_id, db_session):
             res_count += 1
             data_obj = json.loads(row)
 
-            html_output += '<tr id=i_' + checksum + '>'
-            html_output += '<td><input type=checkbox id=d_cb_'+ checksum + ' class=SHFT_cb></td>'
+            html_output += '<tr id="i_' + checksum + '" data-filename="' + data_obj.get('location', '').split(os.sep)[-1] + '">'
+            html_output += '<td><input type="checkbox" id="d_cb_'+ checksum + '" class="SHFT_cb"></td>'
 
-            for entity in Tilde.hierarchy:
-                if not entity['has_column']: continue
-                if not entity['cid'] in Connection.Clients[client_id].usettings['cols']: continue
+            for entity in work.hierarchy:
+                if not entity['has_column'] or entity['cid'] not in Connection.Clients[client_id].usettings['cols']:
+                    continue
 
-                html_output += wrap_cell(entity, data_obj, Tilde.hierarchy_values, table_view=True)
+                html_output += wrap_cell(entity, data_obj, work.hierarchy_values, table_view=True)
 
             #if Connection.Clients[client_id].usettings['objects_expand']: html_output += "<td class=objects_expand><strong>click by row</strong></td>"
             html_output += '</tr>'
         html_output += '</tbody>'
 
-        if not res_count: return ({'msg': 'No objects found.'}, error)
+        if not res_count: return ({'msg': 'No objects found'}, error)
 
         data['html'] = html_output
         return (data, error)
@@ -187,12 +204,14 @@ def tags(req, client_id, db_session):
         if not tids:
             searchables = []
             for tid, cid, topic in db_session.query(model.Topic.tid, model.Topic.cid, model.Topic.topic).order_by(model.Topic.topic).all(): # FIXME assure there are checksums on such tid!
-                try: entity = [x for x in Tilde.hierarchy if x['cid'] == cid][0]
-                except IndexError: return (None, 'Schema and data do not match: different versions of code and database?')
+                try:
+                    entity = [x for x in work.hierarchy if x['cid'] == cid][0]
+                except IndexError:
+                    return (None, 'Schema and data do not match: different versions of code and database?')
 
                 if not entity.get('creates_topic'): continue # FIXME rewrite in SQL
 
-                topic = num2name(topic, entity, Tilde.hierarchy_values)
+                topic = num2name(topic, entity, work.hierarchy_values)
                 searchables.append((tid, topic))
 
                 if not entity.get('has_facet'): continue
@@ -218,7 +237,7 @@ def tags(req, client_id, db_session):
                     'content': [ topic_dict ]
                 })
 
-            for entity in Tilde.hierarchy:
+            for entity in work.hierarchy:
                 if entity['has_slider']:
                     cls, attr = entity['has_slider'].split('.')
                     orm_inst = getattr(getattr(model, cls), attr)
@@ -234,7 +253,7 @@ def tags(req, client_id, db_session):
                         })
 
             categs.sort(key=lambda x: x['sort'])
-            categs = {'blocks': categs, 'cats': Tilde.hierarchy_groups, 'searchables': searchables}
+            categs = {'blocks': categs, 'cats': work.hierarchy_groups, 'searchables': searchables}
 
         else:
             params = {}
@@ -251,16 +270,20 @@ def tags(req, client_id, db_session):
 
     @staticmethod
     def summary(req, client_id, db_session):
-        if len(req['datahash']) != HASH_LENGTH: return (None, 'Invalid request!')
+        if len(req['datahash']) > 100: return (None, 'Invalid request!')
 
         step = -1
         clauses = [model.Lattice.struct_id == model.Structure.struct_id, model.Structure.checksum == req['datahash']]
 
-        if step != -1: clauses.append(model.Structure.step == step)
-        else: clauses.append(model.Structure.final == True)
+        if step != -1:
+            clauses.append(model.Structure.step == step)
+        else:
+            clauses.append(model.Structure.final == True)
 
-        try: struct_id, a11, a12, a13, a21, a22, a23, a31, a32, a33 = db_session.query(model.Lattice.struct_id, model.Lattice.a11, model.Lattice.a12, model.Lattice.a13, model.Lattice.a21, model.Lattice.a22, model.Lattice.a23, model.Lattice.a31, model.Lattice.a32, model.Lattice.a33).filter(and_(*clauses)).one()
-        except NoResultFound: return (None, 'Nothing found!')
+        try:
+            struct_id, a11, a12, a13, a21, a22, a23, a31, a32, a33 = db_session.query(model.Lattice.struct_id, model.Lattice.a11, model.Lattice.a12, model.Lattice.a13, model.Lattice.a21, model.Lattice.a22, model.Lattice.a23, model.Lattice.a31, model.Lattice.a32, model.Lattice.a33).filter(and_(*clauses)).one()
+        except NoResultFound:
+            return (None, 'Nothing found!')
 
         symbols, positions, is_final = [], [], False # TODO
         cell = [[a11, a12, a13], [a21, a22, a23], [a31, a32, a33]]
@@ -269,18 +292,17 @@ def summary(req, client_id, db_session):
             positions.append([x, y, z])
         cif = generate_cif(Atoms(symbols=symbols, cell=cell, positions=positions, pbc=True)) # TODO
 
-        info = db_session.query(model.Grid.info) \
-            .filter(model.Grid.checksum == req['datahash']).one()
+        info = db_session.query(model.Grid.info).filter(model.Grid.checksum == req['datahash']).one()
+        info = json.loads(info[0])
 
         summary = []
-        info = json.loads(info[0])
 
-        for entity in Tilde.hierarchy:
+        for entity in work.hierarchy:
             if not entity['has_summary_contrb']: continue # additional control to avoid redundancy
             #if entity['cid'] > 2000: # TODO apps
 
             catname = str2html(entity['html']) if entity['html'] else entity['category'].capitalize()
-            summary.append( {'category': catname, 'sort': entity.get('sort', 1000), 'content': wrap_cell(entity, info, Tilde.hierarchy_values)} )
+            summary.append( {'category': catname, 'sort': entity.get('sort', 1000), 'content': wrap_cell(entity, info, work.hierarchy_values)} )
 
         summary.sort(key=lambda x: x['sort'])
 
@@ -296,9 +318,11 @@ def summary(req, client_id, db_session):
     def optstory(req, client_id, db_session):
         data, error = None, None
 
-        try: tresholds = db_session.query(model.Struct_optimisation.tresholds) \
+        try:
+            tresholds = db_session.query(model.Struct_optimisation.tresholds) \
             .filter(model.Struct_optimisation.checksum == req['datahash']).one()
-        except NoResultFound: return (None, 'Nothing found!')
+        except NoResultFound:
+            return (None, 'Nothing found!')
 
         data = eplotter( task='optstory', data=json.loads(tresholds[0]) )
 
@@ -308,9 +332,11 @@ def optstory(req, client_id, db_session):
     def estory(req, client_id, db_session):
         data, error = None, None
 
-        try: convergence = db_session.query(model.Energy.convergence) \
+        try:
+            convergence = db_session.query(model.Energy.convergence) \
             .filter(model.Energy.checksum == req['datahash']).one()
-        except NoResultFound: return (None, 'Nothing found!')
+        except NoResultFound:
+            return (None, 'Nothing found!')
 
         data = eplotter( task='convergence', data=json.loads(convergence[0]) )
 
@@ -331,7 +357,6 @@ def settings(req, client_id, db_session):
 
 
 if __name__ == "__main__":
-    Connection = Async_Connection
     Connection.GUIProvider = BerliniumGUIProvider
     DuplexRouter = SockJSRouter(Connection)
 
@@ -341,9 +366,12 @@ def settings(req, client_id, db_session):
     )
     application.listen(settings['webport'], address='0.0.0.0')
 
-    logging.warning("%s (%s backend): http://127.0.0.1:%s" % (CURRENT_TITLE, settings['db']['engine'], settings['webport']))
+    logging.warning("%s serves http://127.0.0.1:%s" % (CURRENT_TITLE, settings['webport']))
+    logging.warning("DB is %s" % DB_TITLE)
     logging.warning("Connections are %s" % Connection.Type)
     logging.warning("Press Ctrl+C to quit")
 
-    try: ioloop.IOLoop.instance().start()
-    except KeyboardInterrupt: pass
+    try:
+        ioloop.IOLoop.instance().start()
+    except KeyboardInterrupt:
+        pass