def activate(self, callback=None, app=None, twisted=False):
self.setup()
if self.swagger.has_api:
swagger_file = '{}/{}'.format(self.swagger.path, self.swagger.file)
if not Path(swagger_file).is_file():
self.logger.info(
'Unable to access swagger file "{}"'.format(swagger_file))
return
swagger_ui = self.get('swagger_ui', 'ui')
app = App(__name__,
specification_dir='{}/{}'.format(getcwd(),
self.swagger.path))
app.add_api(self.swagger.file,
arguments={'title': self.ms_name},
swagger_url=swagger_ui)
self.swagger.add_healthcheck(app)
CORS(app.app)
@app.app.teardown_appcontext
def flush_session_manager(_):
self.db.session.remove()
else:
if not app:
app = Flask(__name__)
CORS(app)
@app.teardown_appcontext
def flush_session_manager(_):
self.db.session.remove()
reactor.suggestThreadPoolSize(200)
client._HTTP11ClientFactory.noisy = False
if callback:
callback(app)
# Sorry, flask_private is the only remotely sane way I can think of doing
# this at the moment. It's a special case for endpoints in the API gateway.
if self.get('flask_private', False, boolean=True):
port = self.get('flask_port')
else:
port = self.flask_port
self.logger.info('* starting listening port "{}"'.format(port))
if twisted:
self.logger.info('* starting Twisted WSGI server')
Twisted(app).run(host='0.0.0.0', port=port, debug=False)
else:
self.logger.info('* starting Flask dev server')
app.run(host='0.0.0.0', port=port, debug=False)
def flask_thread():
resource = 'data/openapi'
if (not resource_exists(__name__, resource)
or not resource_isdir(__name__, resource)):
print(
"Unable to load OpenAPI specifications - installation broken?")
return -1
options = {'swagger_path': swagger_ui_3_path}
spec_dir = resource_filename(__name__, resource)
print("Options: " + str(options))
app = App(__name__, specification_dir=spec_dir, options=options)
app.app.json_encoder = Encoder
app.add_api('landingpage.yaml')
app.add_api('brewerycontrol.yaml')
app.run(host="0.0.0.0", port=5000)
def network(ident):
response = fetch_value(ident)
return response
def echo(ident):
return {'value': ident}
if __name__ == '__main__':
from argparse import ArgumentParser
from os.path import abspath
from os.path import dirname
from os.path import join
from connexion import App
parser = ArgumentParser(__doc__)
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('--port', default=8080, type=int)
parser.add_argument('--server', default='tornado')
parser.add_argument('--api',
default=abspath(join(dirname(__file__), 'api.yaml')))
args = parser.parse_args()
app = App(__name__)
app.add_api(args.api)
app.run(host=args.host, port=args.port, server=args.server)
#!/usr/bin/env python3
from os import getenv, getcwd
from pathlib import Path
from connexion import App
from flask_cors import CORS
from swagger_server.encoder import JSONEncoder
if __name__ == '__main__':
cf_app_env = getenv('VCAP_APPLICATION')
in_cf_env = cf_app_env is not None
if in_cf_env:
import yaml
import json
cwd = getcwd()
config = './swagger_server/swagger/swagger.yaml'
if Path(config).is_file():
with open(config) as io:
code = yaml.load(io)
code['host'] = json.loads(cf_app_env)['application_uris'][0]
with open(config, 'w') as io:
io.write(yaml.dump(code))
app = App(__name__, specification_dir='./swagger/')
CORS(app.app)
app.app.json_encoder = JSONEncoder
app.add_api('swagger.yaml', arguments={'title': 'ONS Microservice'})
app.run(host='0.0.0.0', port=int(getenv('PORT', '5000')), debug=not in_cf_env)
def get_timestamp():
return datetime.now().strftime(("%Y-%m-%d %H:%M:%S"))
out_home={
"Farrell": {
"fname": "Doug",
"lname": "Farrell",
"timestamp": get_timestamp(),
},
"Brockman": {
"fname": "Kent",
"lname": "Brockman",
"timestamp": get_timestamp(),
},
"Easter": {
"fname": "Bunny",
"lname": "Easter",
"timestamp": get_timestamp(),
},
}
app=App(__name__)
@app.route('/')
def home():
return jsonify(out_home)
if __name__=='__main__':
app.run(debug=True,port=6969,host='0.0.0.0')
from connexion import App
import logging
logging.basicConfig(level=logging.INFO)
app = App(__name__)
app.add_api('swagger.yaml')
# set the WSGI application callable to allow using uWSGI
application = app.app
if __name__ == '__main__':
app.run(port=8080, server='gevent')
from connexion import App
import logging
logging.basicConfig(level=logging.INFO)
app = App(__name__)
app.add_api('swagger.yaml')
# set the WSGI application callable to allow using uWSGI
application = app.app
if __name__ == '__main__':
app.run(port=8080, server='gevent')
#!/usr/bin/env python3
##############################################################################
# #
# Microservices header template #
# Date: 18 May 2017 #
# Author: Gareth Bult #
# License: MIT #
# Copyright (c) 2017 Crown Copyright (Office for National Statistics) #
# #
##############################################################################
from connexion import App
from flask_cors import CORS
from .encoder import JSONEncoder
from .configuration import ons_env
if __name__ == '__main__':
ons_env.activate()
app = App(__name__, specification_dir='./swagger/')
CORS(app.app)
app.app.json_encoder = JSONEncoder
app.add_api('swagger.yaml', arguments={'title': 'ONS Microservice'})
app.run(host='0.0.0.0', port=ons_env.port)
#from twisted.internet import reactor
#from flask_twisted import Twisted
#reactor.callLater(1, print, '<<Twisted is running>>')
#Twisted(app).run(port=getenv('PORT',8080))
labels.append(label)
for data in training_data:
containedlabels = list()
for label in labels:
if label in data['ic']:
containedlabels.append(1.0)
else:
containedlabels.append(0.0)
data['ic'] = containedlabels
print("Building network...")
config.neuralnet = network.get_network(256, len(labels))
config.labels = labels
training_input = []
training_output = []
for data in training_data:
training_input.append(data['img'])
training_output.append(data['ic'])
print("Training network...")
history = network.train(config.neuralnet, np.array(training_input),
np.array(training_output))
print("Done, ready for predictions")
app = App(__name__, specification_dir='./')
app.add_api('swagger.yml')
app.run(debug=True, host='0.0.0.0', use_reloader=False)
