app.py.j2

import argparse
import json
import os
import pyld
import requests
import sqlite3
import yaml
from flask import Flask, jsonify, g, Response, request
from flasgger import Swagger
app = Flask(__name__)
import flask

{% if options.swagger %}
template = {{ options.swagger }}
{% else %}
template = {
  "swagger": "2.0",
  "info": {
    "title": "{{ service.title }}",
    "description": "API for X data",
    "contact": {
      "responsibleOrganization": "x-org",
      "responsibleDeveloper": "x-dev",
      "email": "x@x.org",
      "url": "www.x.org",
    },
    "termsOfService": "http://x.org/terms",
    "version": "0.0.1"
  },
  "schemes": [
    "https",
    "http"
  ]
}

{% endif %}
app.config['SWAGGER'] = {
    'title': 'SmartBag API',
    'uiversion': 3
}

swagger = Swagger(app, template=template)

{% for db in datasets %}
def _jsonify (obj):
    return Response(json.dumps(obj, indent=2), mimetype='application/json')
def get_{{ db.name }}_db():
    db = getattr(g, '_{{ db.name }}', None)
    if db is None:
        db_path = "{{ db.db_path }}"
        db_path = os.path.join (os.path.dirname(__file__), db_path)
        db = g._{{ db.name }} = sqlite3.connect (db_path)
    return db

@app.teardown_appcontext
def close_{{ db.name }}_connection(exception):
    db = getattr(g, '_{{ db.name }}', None)
    if db is not None:
        db.close()
{{ db.name }}_connection = sqlite3.connect ("{{ db.db_path }}")

@app.route('/{{ db.name }}_metadata/')
def {{ db.name }}_metadata ():
   """ Get service metadata 
   ---
   responses:
     200:
       description: ...

   """
   return _jsonify({{ db.jsonld_context_text }})

@app.route('/{{ db.name }}_examples/')
def {{ db.name }}_examples ():
   """ Get a few example rows
   ---
   responses:
     200:
       description: ...
       
   """
   return _jsonify({{ db.example_rows }})

{% for column in db.columns %}
@app.route('/{{ db.name }}_{{ column }}/<{{ column }}>/')
def {{ db.name }}_{{ column }}({{ column }}):
    """ Get row by {{ column }}
    ---
    parameters:
      - name: {{ column }}
        in: path
        type: string
        required: true
        x-valueType:
          - {{ db.columns[column].type }}
        x-requestTemplate:
          - valueType: {{ db.columns[column].type }}
            template: /{{db.name }}_{{ column }}/{% raw %}{{ input }}{% endraw %}
      - name: include_similar
        in: query
        type: boolean
        default: false
        x-valueType:
          - http://schema.org/boolean
        x-requestTemplate:
          - valueType: http://schema.org/boolean

    responses:
      200:
        description: success
        x-responseValueType:{% for response_col in db.columns.values() %}
          - path: {{ response_col.name }}
            valueType: {{ response_col.type }}{% endfor %}
        x-JSONLDContext: /{{ db.name }}_metadata
    """
    include_similar = flask.request.args.get("include_similar")
    results = []
    cursor = get_{{ db.name }}_db ().cursor ()
    if include_similar == 'true':
        data = cursor.execute (
            "SELECT * FROM {{ db.name }} where lower({{ column }}) LIKE lower('%{0}%')".format (
                {{ column }}))
    else:
        data = cursor.execute (
            "SELECT * FROM {{ db.name }} where lower({{ column }}) = lower('{0}')".format (
                {{ column }}))
    for r in data:
        row = {}
        {% for col in db.columns %}row["{{ col }}"]=r[{{ loop.index0 }}]
        {% endfor %}
        results.append (row)
    cursor.close ()
    return _jsonify(results)

{% endfor %}
{% endfor %}


@app.route('/specification/')
def spec ():
    """ Get the smartapi specification.
    ---
    responses:
     200:
       description: ...              
    """
    text = ""
    spec_path = os.path.join (os.path.dirname(__file__), "smartapi.yaml")
    if not os.path.exists (spec_path):
        port = app.config['SWAGGER']['port']
        obj = requests.get (f"http://localhost:{port}/apispec_1.json").json ()
        with open (spec_path, "w") as stream:
            yaml.dump (obj, stream, default_flow_style=False)
    with open (spec_path) as stream:
        text = stream.read ()
    return text


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='smartBag Server')
    parser.add_argument('-p', '--port', type=int, help='Port to run service on.', default=5000)
    args = parser.parse_args ()
    app.config['SWAGGER']['port'] = args.port
    
    app.run(host='0.0.0.0', port=args.port, debug=True, threaded=True)