Format selection in web-app

Refactor

Author: HeersGBV

LidoRDFConverter.py

@@ -4,10 +4,19 @@
 import os
 import shutil
 import rdflib as RF
+from rdflib.namespace import NamespaceManager
 import urllib.request as ulr
 import urllib.parse as ulp
 from lxml import etree
 
+def p_log(f):
+    '''Decorator for logging function output'''
+    def wrapped(*args, **kwargs):
+        t = f(*args, **kwargs)
+        print(t)
+        return t
+    return wrapped
+
 
 # prefix namespace mapping
 NAMESPACE_MAP = {
@@ -22,15 +31,6 @@
 RESUMPTION_TAG = f'{{{OAI_SCHEMA_URL}}}resumptionToken'
 
 
-def make_short_uri(uri: str, **kw) -> RF.term.URIRef:
-    '''Returns URI' like e.g. crm:Enn_cccc'''
-    # tag = kw.get('tag',None)
-    for k, v in NAMESPACE_MAP.items():
-        if uri.startswith(f"{k}:"):
-            return v[uri.split(':')[-1]]
-    return RF.term.URIRef(uri)
-
-
 def isURI(uri: str) -> bool:
     '''Checks if a string is a valid URI'''
     return ulp.urlparse(uri).netloc != ''
@@ -100,14 +100,31 @@ def strip_schema(url: str) -> str:
     """Strips the schema from a URL"""
     return re.sub(r"^https?:", '', url).strip().strip('/')
 
+def make_curie_uri(uri: str, **kw) -> RF.term.URIRef:
+    '''Creates a URIRef from a CURIE or URI string'''
+    try:
+        nsm = kw.get('graph').namespace_manager
+        return nsm.expand_curie(uri)
+    except:
+        return RF.term.URIRef(uri)
+
+def make_id_node(id_str: str, **kw) -> RF.URIRef:
+    '''Creates an RDF node (BNode or URIRef) from id string and a mode'''
+    '''Gets the ID mode and graph from kw arguments'''
+    mode = kw.get('mode', x3ml.IDMode.LIDO_ID)
+    if mode == x3ml.IDMode.PATH:
+        return RF.BNode(hash(id_str))
+    uri = f'n4o:{hash(id_str)}'
+    try:
+        nsm = kw.get('graph').namespace_manager
+        return nsm.expand_curie(uri)
+    except:
+        return RF.term.URIRef(uri)
 
-def make_n4o_id(text: str, **kw) -> RF.URIRef:
-    """Creates a N4O ID from text"""
-    return NAMESPACE_MAP['n4o'][f"{hash(text)}"]
 
 
-def make_object(info) -> RF.URIRef | RF.Literal:
-    """Creates an RDF object (URIRef or Literal) from info and text"""
+def make_plain_node(info) -> RF.URIRef | RF.Literal:
+    """Creates an RDF node (URIRef or Literal) from info"""
     if isURI(info.text):
         return RF.URIRef(proper_uri(info.text))
     return RF.Literal(info.text, lang=info.lang)
@@ -119,10 +136,11 @@ def make_object(info) -> RF.URIRef | RF.Literal:
 def add_triples(graph, mapping: x3ml.Mapping, recID: str, **kw) -> None:
     '''Add triples to the graph'''
     info = mapping.info
-    if id_S := info.id.strip():
-        id_S = recID + '-' + id_S
-        S = make_n4o_id(id_S, tag='S')
-        triples = [(S, RF.RDF.type, make_short_uri(mapping.S.entity, tag='S'))]
+    if id_S := info.get_id(recID):
+        kw.update({'graph':graph,'mode':info.mode,'tag':'S'})
+        S = make_id_node(id_S, **kw)
+        triples = [(S, RF.RDF.type, make_curie_uri(mapping.S.entity, **kw))]
+        
         for po in mapping.POs:
             triples += get_po_triples(S, recID,  po, **kw)
         if len(triples) > 1:  # at least one PO triple
@@ -134,19 +152,21 @@ def get_po_triples(S, recID, po: x3ml.PO, **kw) -> list:
     '''Compile triples from PO data'''
     triples = []
     if po.valid:
-        P = make_short_uri(po.P.entity, tag='P')
+        kw.update({'tag':'P'})
+        P = make_curie_uri(po.P.entity, **kw)
+        kw.update({'tag':'O'})
         for info in po.infos:
             if info.hasID():
+                kw.update({'mode':info.mode})
                 id_O = info.get_id(recID)
-                O = make_n4o_id(id_O, tag='O')
+                O = make_id_node(id_O, **kw)
                 if (O != S):
-                    Pt = RF.RDF.type
-                    Ot = make_short_uri(po.O.entity, tag='O')
-                    triples.append((S, Pt, Ot))
                     triples.append((S, P, O))
+                    Ot = make_curie_uri(po.O.entity, **kw)
+                    triples.append((O, RF.RDF.type, Ot))
             else:
                 if info.text:
-                    O = make_object(info)
+                    O = make_plain_node(info)
                     triples.append((S, P, O))
     return triples
 

app.py

@@ -1,23 +1,27 @@
 import xml.etree.ElementTree as ET
 import LidoRDFConverter as LRC
 from pathlib import Path
-from x3ml_classes import  X3ml
-from flask import  Flask, render_template, request,  jsonify, make_response
+from x3ml_classes import X3ml
+from flask import Flask, render_template, request,  jsonify, make_response
 import logging
 import json
+from dataclasses import dataclass
 
 from waitress import serve
 from argparse import ArgumentParser, BooleanOptionalAction
 
-app = Flask(__name__,template_folder='templates', static_folder='static', static_url_path='/assets')
+app = Flask(__name__, template_folder='templates', static_folder='static', static_url_path='/assets')
+
 
 def dlftMappingFile():
     return Path('./defaultMapping.x3ml')
 
+
 def dlftLidoFile():
     return Path('./defaultLido.xml')
 
-def convert_lido_str(lido_str, x3ml_str,format='turtle'):
+
+def convert_lido_str(lido_str, x3ml_str, format='turtle'):
     '''Converts LIDO XML string to RDF using the provided X3ML mapping string.
     Returns the RDF string in the specified format.'''
     if lido_str:
@@ -26,36 +30,31 @@ def convert_lido_str(lido_str, x3ml_str,format='turtle'):
         return graph.serialize(format=format)
     return ''
 
-def get_version_data():
-    version = Path('./version.txt')
-    if version.exists():
-        ver_str = version.read_text()
-        last_line = ver_str.split('\n')[-1]
-        tokens = last_line.split(':', 3)
-        if len(tokens) == 3: 
-            return {'date':tokens[0],'commit':tokens[1],'version':tokens[2]}
-        return {'date':'','commit':'','version':'0'}
-    return 'unkown'
-
-VERSION_DATA = get_version_data()
-
 #############################################################################
 
+
 @app.route('/')
 def index():
-    return render_template('index.html', version=VERSION_DATA.get('version','unkown'))
+    return render_template('index.html', version=app.config['version'].value)
+
+
+@app.route('/version')
+def version():
+    return jsonify(app.config['version'])
+
 
 @app.route('/barriere')
 def barriere():
     return render_template('barriere.html')
 
+
 @app.route('/json_to_x3ml', methods=['POST'])
 def json_to_x3ml():
     parm = request.get_json()
     if js := parm.get('x3ml'):
         model = X3ml.fromJSON(js)
         x3ml_str = model.to_str()
-        return jsonify({'status': 'success', 'x3ml': x3ml_str})        
+        return jsonify({'status': 'success', 'x3ml': x3ml_str})
     return jsonify({'status': 'failed', 'message': 'No mapping data provided!'})
 
 
@@ -92,14 +91,16 @@ def upload_mapping():
 def run_mappings():
     response_object = {'status': 'success'}
     parm = request.get_json()
-    lido_data = parm['data']
+    lido_data = parm.get('data','')
     if js := parm.get('x3ml'):
         model = X3ml.fromJSON(js)
-        response_object = {'status': 'success', 'message': 'Mappings applied to Lido!'}
-        response_object['text'] = convert_lido_str(lido_data, model.to_str())
+        format = parm.get('format','turtle')
+        response_object = {'status': 'success', 'message': 'Mappings applied to Lido!', 'format':format}
+        response_object['text'] = convert_lido_str(lido_data, model.to_str(),format=format)
         return jsonify(response_object)
     return jsonify({'status': 'failed', 'message': 'No Lido data provided!'})
 
+
 @app.route('/convert', methods=['POST'])
 def convert():
     # TODO: catch error and provide better error response e.g. code 400 for malformed LIDO
@@ -113,19 +114,52 @@ def convert():
         else:
             mapping_data = dlftMappingFile().read_text()
         lido_data = request.files['file'].read().decode('utf-8')
-        format = request.form.get('format','turtle')
+        format = request.form.get('format', 'turtle')
     else:
         mapping_data = dlftMappingFile().read_text()
         lido_data = request.get_data()
-        format ='turtle'
+        format = 'turtle'
     try:
-        rdf_str = convert_lido_str(lido_data, mapping_data,format=format)
+        rdf_str = convert_lido_str(lido_data, mapping_data, format=format)
         response = make_response(rdf_str, 200)
         response.mime_type = f"text/{format}"
     except Exception as e:
         return jsonify({'error': str(e)}), 400
     return response
 
+
+@dataclass
+class Version():
+    date: str = ''
+    commit: str = ''
+    value: str = '???'
+
+    def update(self, tokens:list):
+        ''' Updates attributes from tokens '''
+        data = {'date': tokens[0], 'commit': tokens[1], 'value': tokens[2]}
+        self.__dict__.update(data)
+        return self
+
+    @classmethod
+    def from_tokens(cls, tokens):
+        ''' Creates an object from tokens '''
+        if len(tokens) == 3:
+            return cls().update(tokens)
+        return cls()
+
+
+def get_version_data():
+    ''' Reads version data from file into the app configuration'''
+    tokens = []
+    ver_file = Path('./version.txt')
+    if ver_file.exists():
+        # Get last line and split it into 3 tokens
+        text = ver_file.read_text()
+        last_line = text.splitlines()[-1]
+        tokens = last_line.split(':', 3)
+    app.config['version'] = Version.from_tokens(tokens)
+
+
 if __name__ == '__main__':
     parser = ArgumentParser()
     parser.add_argument('-w', '--wsgi', action=BooleanOptionalAction, help="Use WSGI server")
@@ -135,8 +169,9 @@ def convert():
 
     if args.log:
         logging.basicConfig(filename='app.log', level=logging.INFO)
-        
-  
+
+    get_version_data()
+
     if args.wsgi:
         print(f"Starting WSGI server at http://localhost:{args.port}/")
         serve(app, host="0.0.0.0", port=args.port)

static/lidostyle.css

@@ -23,73 +23,13 @@
   font-family: monospace;
 }
 
-/* CSS */
-.button-blue {
-  background-color: #0095ff;
-  border: 1px solid transparent;
-  border-radius: 3px;
-  box-shadow: rgba(255, 255, 255, 0.4) 0 1px 0 0 inset;
-  box-sizing: border-box;
-  color: #fff;
-  cursor: pointer;
-  display: inline-block;
-  font-family: -apple-system, system-ui, "Segoe UI", "Liberation Sans",
-    sans-serif;
-  font-size: 10px;
-  font-weight: 400;
-  line-height: 1;
-  margin: 2px;
-  outline: none;
-  padding: 8px 0.8em;
-  position: relative;
-  text-align: center;
-  text-decoration: none;
-  user-select: none;
-  -webkit-user-select: none;
-  touch-action: manipulation;
-  vertical-align: baseline;
-  white-space: nowrap;
-}
-
-.button-blue:hover,
-.button-blue:focus {
-  background-color: #07c;
-}
-
-.button-blue:focus {
-  box-shadow: 0 0 0 4px rgba(0, 149, 255, 0.15);
-}
-
-.button-blue:active {
-  background-color: #0064bd;
-  box-shadow: none;
-}
-
-.visible-scrollbar,
-.invisible-scrollbar,
-.mostly-customized-scrollbar {
-  display: block;
-  width: 10em;
-  overflow: auto;
-  height: 2em;
-  padding: 1em;
-  margin: 1em auto;
-  outline: 2px dashed cornflowerblue;
-}
-
-.invisible-scrollbar::-webkit-scrollbar {
-  display: none;
-}
-
-/* Demonstrate a "mostly customized" scrollbar
- * (won't be visible otherwise if width/height is specified) */
-.mostly-customized-scrollbar::-webkit-scrollbar {
-  width: 5px;
-  height: 8px;
-  background-color: #aaaaaa; /* or add it to the track */
+.styled select {
+  width: 300px;
+  height: 34px;
+  font-size: 12px;
 }
 
-/* Add a thumb */
-.mostly-customized-scrollbar::-webkit-scrollbar-thumb {
-  background: black;
-}
+.styled {
+  width: 500px;
+  margin-bottom: 5px;
+}