def run(self, ngrok=False) -> None:
if ngrok:
run_with_ngrok(self._app)
self._app.run()
def startWebServer(self):
self.log("INFO", "Starting web server")
app = Flask("Python server")
run_with_ngrok(app)
self.app = app
@app.route("/logs")
def logs():
try:
s = ""
with open("log.txt", 'r') as fp:
for line in fp.readlines():
s += line + "<br>"
return make_response(s, 200)
except:
return make_response("No logs", 200)
@app.route("/start")
def start():
self.startProcessingFrames()
self.log("START", "Starting server")
return make_response("Starting server", 200)
@app.route("/stop")
def stop():
self.stopProcessingFrames()
self.log("STOP", "Stopping server")
return make_response("Stopping server", 200)
@app.route("/updatep")
def updatePreprocessingValues():
self.log("UPDATE", "Updating preprocessing values")
self.loadPreprocessingValuesFromWeb()
return make_response("Updating preprocessing values", 200)
#server commands to stop processing thread
@app.route("/startfp")
def startfp():
self.startProcessingFrames()
return make_response("Done!", 200)
@app.route("/stopfp")
def stopfp():
self.stopProcessingFrames()
return make_response("Done!", 200)
@app.route("/camera/<cameraId>")
def sendProcessedFrame(cameraId):
with self.lock:
if self.xo == 1:
self.log("HAP", "Value changed")
self.xo = 0
if cameraId not in list(self.cameras.keys()):
self.log("WARN", "Camera doesn't exist")
return make_response("camera doesn't exist", 404)
#self.log("INFO", "sending processing frame")
return Response(
self.gen(cameraId),
mimetype='multipart/x-mixed-replace; boundary=frame')
#self.app.run(host='0.0.0.0', port=self.SERVER_PORT, debug=True,
#threaded=True, use_reloader=False)
self.app.run()
from flask import Flask, render_template, request
from flask_ngrok import run_with_ngrok
import nltk
from keras.models import load_model
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
# chat initialization
model = load_model("static/models/chatbot_model.h5")
intents = json.loads(open("intents.json").read())
words = pickle.load(open("words.pkl", "rb"))
classes = pickle.load(open("classes.pkl", "rb"))
chatbot_app = Flask(__name__)
run_with_ngrok(chatbot_app)
# @chatbot_app.route("/")
# def home():
# return render_template("ChatBot.html")
@chatbot_app.route("/get", methods=["POST"])
def chatbot_response():
msg = request.form["msg"]
if msg.startswith('my name is'):
name = msg[11:]
ints = predict_class(msg, model)
res1 = getResponse(ints, intents)
res = res1.replace("{n}", name)
elif msg.startswith('hi my name is'):
def main():
print('Web-panel is started!')
db_session.global_init()
address = run_with_ngrok(app)
app.run()
from flask import Flask, jsonify, request, send_file
from flask_ngrok import run_with_ngrok
from PIL import Image
import time
server = Flask(__name__)
run_with_ngrok(server)
from sightings import Sightings
import predictor
import uuid
import json
import socket
print(socket.gethostbyname(socket.getfqdn(socket.gethostname())))
sightings = Sightings()
@server.route("/still-data", methods=["POST"])
def load_still():
rtime = time.time()
data = request.files.get('still')
img = Image.open(data.stream)
sid = str(uuid.uuid1().int)
img.save("stills/" + sid + ".png")
jsondata = json.loads(request.form['json'])
num_geese, bbox = predictor.infer(sid)
if num_geese > 0:
sightings.add(sid, rtime, jsondata["location"], jsondata["telemetry"],
num_geese, bbox)
return "Success", 200
#predictions
predictions = model.predict(X_test)
#metrics
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, predictions)*100)
predictions = model.predict([[22.0, 1, 0, 7.2500, 1, 0, 1, 0, 1]])
predictions
!pip install flask-ngrok
from flask_ngrok import run_with_ngrok
from flask import Flask, jsonify
app = Flask(__name__)
run_with_ngrok(app) #starts ngrok when app is running
@app.route("/<int:Age>/<int:SibSp>/<int:Parch>/<float:Fare>/<Gender>/<int:PClass>/<Place>")
def home(Age, SibSp, Parch, Fare, Gender, PClass, Place):
p = []
p += [Age, SibSp, Parch, Fare]
if Gender.casefold() == "m" :
p+=[1]
else:
p+=[0]
if PClass == 2:
p+=[1,0]
elif PClass == 3:
p+=[0,1]
else:
p+=[0,0]
if Place.casefold() == "queenstown":
# System info
@app.route("/sysinfo")
def sysinfo():
sysinfo_data = {
'cpu_cores': 2,
'cpu_threads': 4,
'ram': 24,
'gpu_ram': 16,
'gpu_name': "V100",
'hdd_space': "100",
'hdd_space_free': "30",
'Running in Colab': IN_COLAB,
}
return flask.render_template('sysinfo.html', sysinfo=sysinfo_data)
@app.route("/api/add-image/<seed>")
def add_image(seed):
project.add_image(seed)
return redirect(url_for('images'))
if __name__ == "__main__":
if IN_COLAB:
print("Colab: YES")
run_with_ngrok(app) # In Google Colab run with Ngrok
else:
print("Colab: No")
app.run()
app.config['UPLOAD_EXTENSIONS'] = ['.jpg', '.png']
app.config[
'UPLOAD_FOLDER'] = './food-recognition/static/uploads' # The same path in prediction.html !!!
#app.config['MODEL_PATH'] = 'model/mask_rcnn_food-challenge_0026.h5'
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
app.secret_key = "thisisasupersecretkey"
app.config['SECRET_KEY'] = "thisisasupersecretkey"
app.config.update(
DROPZONE_REDIRECT_VIEW='prediction', # set redirect view
DROPZONE_MAX_FILES=20,
)
# creation of a dropzone
dropzone = Dropzone(app)
run_with_ngrok(app) # comment if not using colab
# instantiation of detector
detector = Detector()
#========================= UTILS FUN ======================================#
def validate_image(stream):
"""
check if is a valid image
"""
header = stream.read(512)
stream.seek(0)
format = imghdr.what(None, header)
if not format:
return None
import hashlib # secure hashes and message digests
from time import ctime
import json
import requests
import urllib.parse
from flask import Flask, redirect, url_for, session, request, jsonify
from flask_oauthlib.client import OAuth
from flask_ngrok import run_with_ngrok
from flask import request
from flask import render_template
import ntplib
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
flaskApp = Flask(__name__)
run_with_ngrok(flaskApp)
database = "database.db"
flaskApp.config['GOOGLE_ID'] = "937632115184-49gtf8rtirdg5000g0eiie325k25mpvg.apps.googleusercontent.com"
flaskApp.config['GOOGLE_SECRET'] = "4f_qgKmV4vTwALuWlaLdV6n5"
flaskApp.debug = True
flaskApp.secret_key = 'development'
oauth = OAuth(flaskApp)
google = oauth.remote_app(
'google',
consumer_key=flaskApp.config.get('GOOGLE_ID'),
consumer_secret=flaskApp.config.get('GOOGLE_SECRET'),
request_token_params={
'scope': 'email'
},
base_url='https://www.googleapis.com/oauth2/v1/',
from flask import Flask, request
import flask_ngrok
import logging
# библиотека, которая нам понадобится для работы с JSON
import json
# создаём приложение
# мы передаём __name__, в нем содержится информация,
# в каком модуле мы находимся.
# В данном случае там содержится '__main__',
# так как мы обращаемся к переменной из запущенного модуля.
# если бы такое обращение, например,
# произошло внутри модуля logging, то мы бы получили 'logging'
app = Flask(__name__)
flask_ngrok.run_with_ngrok(app)
# Устанавливаем уровень логирования
logging.basicConfig(level=logging.INFO)
# Создадим словарь, чтобы для каждой сессии общения
# с навыком хранились подсказки, которые видел пользователь.
# Это поможет нам немного разнообразить подсказки ответов
# (buttons в JSON ответа).
# Когда новый пользователь напишет нашему навыку,
# то мы сохраним в этот словарь запись формата
# sessionStorage[user_id] = {'suggests': ["Не хочу.", "Не буду.", "Отстань!" ]}
# Такая запись говорит, что мы показали пользователю эти три подсказки.
# Когда он откажется купить слона,
# то мы уберем одну подсказку. Как будто что-то меняется :)
sessionStorage = {}
from flask import Flask, render_template, redirect, request
import os
import sqlite3
import config as con
from work_with_db import db_session
from forms.user import RegisterForm, LoginForm
from work_with_db.Users import User
from flask_login import LoginManager, login_user
from locations import location_forest, location_caves, location_fields, attack
from flask_ngrok import run_with_ngrok
con.app = Flask(__name__)
run_with_ngrok(con.app)
con.app.config['SECRET_KEY'] = 'yandexlyceum_secret_key'
login_manager = LoginManager()
login_manager.init_app(con.app)
item = ''
@login_manager.user_loader
def load_user(user_id):
db_sess = db_session.create_session()
return db_sess.query(User).get(user_id)
@con.app.route('/', methods=['GET', 'POST'])
@con.app.route('/log_in', methods=['GET', 'POST'])
def login():
con.hero.name = None
form = LoginForm()
def run_app():
if get_arg() in ('colab', 'google-colab', 'google', 'notebook'):
flask_ngrok.run_with_ngrok(app)
app.app.run()
else:
app.app.run(threaded=True, host='0.0.0.0', port=5000)
import json
import time
from flask import Flask, jsonify, request
from flask_restful import Resource, Api
from flask_restful import reqparse
from flask_ngrok import run_with_ngrok
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
flags = tf.flags
FLAGS = flags.FLAGS
serverapp = Flask(__name__)
api = Api(serverapp)
run_with_ngrok(serverapp) # Start ngrok when app is run
tokenizer = ""
estimator = ""
basic_tokenizer = ""
global eval_examples, eval_features
eval_features = list()
eval_examples = list()
## Required parameters
flags.DEFINE_string(
"bert_config_file", "HanBert-54kN-MRC/bert_config.json",
"The config json file corresponding to the pre-trained BERT model. "
"This specifies the model architecture.")
flags.DEFINE_string("vocab_file", "HanBert-54kN-MRC/vocab_54k.txt",
import os
from flask_ngrok import run_with_ngrok
from flask import Flask, render_template, request, send_from_directory, jsonify
from werkzeug.utils import secure_filename
from fastai.vision import *
app = Flask(__name__)
run_with_ngrok(app) # Start ngrok when app is run
UPLOAD_DIR = '../uploads'
RESULT_DIR = 'results'
MAPPING = {
0: '၀',
1: '၁',
2: '၂',
3: '၃',
4: '၄',
5: '၅',
6: '၆',
7: '၇',
8: '၈',
9: '၉'
}
def create_folders():
if not os.path.isdir(UPLOAD_DIR):
os.makedirs(UPLOAD_DIR)
if not os.path.isdir(RESULT_DIR):
os.makedirs(RESULT_DIR)
from flask import Flask, request
from flask_ngrok import run_with_ngrok
import logging
import json
app = Flask(__name__)
run_with_ngrok(app) # для того что бы можно было подключится по https
# потому что в Webhook URL должна быть указана
# схема https, а http не работает
logging.basicConfig(level=logging.INFO)
sessionStorage = {}
@app.route('/post', methods=['POST'])
def main():
logging.info(f'Request: {request.json!r}')
response = {
'session': request.json['session'],
'version': request.json['version'],
'response': {
'end_session': False
}
}
handle_dialog(request.json, response)
logging.info(f'Response: {response!r}')
parser.add_argument('nX')
args = parser.parse_args() # creates dict
print(args.values())
X_new = np.fromiter(args.values(), dtype=float) # convert input to array
out = {'Prediction': BIO_MODEL.predict([X_new])[0]}
print(out)
return out, 200
if __name__ == '__main__':
# serialize model
#joblib.dump(clf, 'biodeg.mdl')
app = Flask(__name__)
run_with_ngrok(app) #starts ngrok when the app is run only for google colab
API = Api(app)
BIO_MODEL = joblib.load('./biodeg.mdl')
@app.route("/")
def home():
return "<!DOCTYPE html>\
<html>\
<body>\
<h2>HTML Forms</h2>\
<form method='post' action='/predict'>\
<label for='SpMax_L'>SpMax_L:</label><br>\
<input type='text' id='SpMax_L' name='SpMax_L' value=''><br>\
<label for='J_Dz(e)'>J_Dz(e):</label><br>\
<input type='text' id='J_Dz(e)' name='J_Dz(e)' value=''><br>\
<label for='nHM'>nHM:</label><br>\
<input type='text' id='nHM' name='nHM' value=''><br>\
def main():
run_with_ngrok(app)
app.run()
import torch
from flask_ngrok import run_with_ngrok
import flask
from flask import Flask, request, render_template
import json
from transformers import BartTokenizer, BartForConditionalGeneration, BartConfig
from transformers import T5Tokenizer, T5ForConditionalGeneration, T5Config
BART_PATH = 'bart-large'
T5_PATH = 't5-base'
# BART_PATH = 'model/bart'
# T5_PATH = 'model/t5'
app = Flask(__name__)
# ngrok for this to work in Google collab - https://medium.com/@kshitijvijay271199/flask-on-google-colab-f6525986797b
run_with_ngrok(app) #starts ngrok when the app is run
bart_model = BartForConditionalGeneration.from_pretrained(BART_PATH,
output_past=True)
bart_tokenizer = BartTokenizer.from_pretrained(BART_PATH, output_past=True)
t5_model = T5ForConditionalGeneration.from_pretrained(T5_PATH)
t5_tokenizer = T5Tokenizer.from_pretrained(T5_PATH)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
def bart_summarize(input_text, num_beams=4, num_words=50):
input_text = str(input_text)
input_text = ' '.join(input_text.split())
input_tokenized = bart_tokenizer.encode(input_text,
return_tensors='pt').to(device)
summary_ids = bart_model.generate(input_tokenized,
def ship_it():
app = Flask(__name__)
run_with_ngrok(app)
app.config.SWAGGER_UI_DOC_EXPANSION = 'list'
app.config.SWAGGER_UI_REQUEST_DURATION = True
hostfile = sys.argv[0]
is_running_in_notebook = 'ipykernel_launcher.py' in hostfile
hash = hashlib.md5(open(hostfile, 'rb').read()).hexdigest()
filename = os.path.basename(hostfile)
api = Api(app,
version=hash,
title=f'{filename} API',
description=f'API for {filename} as of {datetime.now()}',
ordered=True)
# ns = api.namespace('functions', description='Call these')
# utility namespace? for dumping files etc?
def call_with_request_data(f):
@wraps(f)
def wrapper(self): # Discards the self passed in
data = request.get_json(force=True)
return f(*[v for k, v in data.items()])
return wrapper
def make_class(name, f):
function_with_input = call_with_request_data(f)
new_class = type(name, (Resource, ), {
"post": function_with_input,
})
return new_class
def add_resource(name, f):
resource = make_class(name, f)
api.route(f'/{name}', methods=['POST'])(resource)
parameter_names = f.__code__.co_varnames
# TODO: default values, example values, args, kwargs
# TODO: See how fire gets parameter types etc https://flask-restplus.readthedocs.io/en/stable/swagger.html#documenting-the-fields
# TODO: use api.param? or keep all in json? query params have size limits but are bookmarkable, but I guess
# TODO: autogen a requests script to query server from python?
# TODO: Validation
# TODO: Better error messages, see fire trace @api.response(404, 'User not found.') api.abort(404)
# TODO: working with file uploads?
# TODO: Hot reloading???
# TODO: Use type hints to guess field type if available
# TODO: Use return doc to specify output shape @api.marshal_with(model) for output shape
sig = signature(f)
model = api.model(
f'{name}_parameters', {
n: fields.String(required=True, example=f"<{n}>")
for n in parameter_names
})
api.doc(description=str(sig), body=model)(resource)
if is_running_in_notebook:
calling_module = sys.modules['__main__']
else:
calling_module = importlib.import_module(
os.path.basename(hostfile)[:-3])
functions = inspect.getmembers(calling_module, inspect.isfunction)
for fn_name, fn in functions:
if os.path.basename(fn.__code__.co_filename) == os.path.basename(hostfile)\
or (is_running_in_notebook and '<ipython-input' in str(fn.__code__.co_filename)):
add_resource(fn_name, fn)
app.run()
return jsonify(results=results)
except:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify("invalid image url")
elif request.method == 'POST':
try:
file = request.files['file']
app.logger.debug('file uploaded - %s', file)
url = request.form.get("url", None)
app.logger.debug('url provided - %s', url)
input_tensor = transform_image(read_file(upload=file, url=url))
values, indices = get_topk(input_tensor)
results = render_prediction(values, indices)
return jsonify(results=results)
except:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify("invalid image")
else:
app.logger.debug("Error: %s", traceback.print_exc())
return jsonify('invalid request')
if __name__ == '__main__':
run_with_ngrok(app)
app.run()
#
# Johnny Wong
# Flask App for PubMix
#
#########################
import os
from flask import Flask, render_template, redirect, url_for, session, request, flash, get_flashed_messages
from flask_ngrok import run_with_ngrok
from util import db
# instantiate Flask Object
app = Flask(__name__)
app.secret_key = os.urandom(32)
run_with_ngrok(app) # start ngrok when app run
DB_FILE = "data/pubmix.db"
db.create_db()
@app.route("/")
def login():
'''Login Page'''
return render_template('index.html')
@app.route("/register")
def register():
'''Register Page'''
return render_template('register.html')
@app.route("/authenticate", methods=['POST'])
