def main(sdk_path, test_path):
sys.path.insert(0, sdk_path)
import dev_appserver
dev_appserver.fix_sys_path()
sys.path.insert(1, os.path.join(os.path.abspath('.'), 'lib'))
sys.path.insert(1, os.path.join(os.path.abspath('.')))
try:
import config
except ImportError:
raise Exception('Unable to load config module. Paths are most likely screwed up. Current path is: %r and has %r' % (
os.path.abspath('.'), os.listdir(os.path.abspath('.'))
))
config.enable_debug_panel = False
#
# This must always be imported first.
from flask import logging
from main import app
logger = logging.create_logger(app)
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
logger.addHandler(console)
suite = unittest.loader.TestLoader().discover(test_path)
unittest.TextTestRunner(verbosity=2).run(suite)
def logger(self):
if self._logger and self._logger.name == self.logger_name:
return self._logger
with _logger_lock:
if self._logger and self._logger.name == self.logger_name:
return self._logger
from flask.logging import create_logger
self._logger = rv = create_logger(self)
return rv
def logger(self):
"""
更为详细完整的代请见flask module的app.py文件
"""
if self.__logger:
return self.__logger
if not self.__logger: # 多线程创建
_logger_lock.acquire()
if not self.__logger:
self.__logger = logging.create_logger(self)
_logger_lock.release()
return self.logger
def logger(self):
"""A :class:`logging.Logger` object for this application. The
default configuration is to log to stderr if the application is
in debug mode. This logger can be used to (surprise) log messages.
Here some examples::
app.logger.debug('A value for debugging')
app.logger.warning('A warning ocurred (%d apples)', 42)
app.logger.error('An error occoured')
.. versionadded:: 0.3
"""
if self._logger and self._logger.name == self.logger_name:
return self._logger
with _logger_lock:
if self._logger and self._logger.name == self.logger_name:
return self._logger
from flask.logging import create_logger
self._logger = rv = create_logger(self)
return rv
from flask import Flask, url_for
#from flaskext.compass import Compass
from flask.logging import create_logger
from hackbox import template_helper
import os
app = Flask(__name__)
app.config.from_pyfile('config.py')
app.jinja_env.globals.update(helper=template_helper)
#app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
#compass = Compass(app)
logger = create_logger(app)
try:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
except ImportError: pass
import hackbox.views
# Author: Raul Gomez (rg9907) # # Email: [email protected] # ################################################################################ """ import logging from logging import FileHandler from flask import Flask from flask.logging import create_logger from app.routes import ROUTES, ERRORS #from dotenv import load_dotenv #load dev env vars #load_dotenv() # redirect http to https APP = Flask(__name__) LOG = create_logger(APP) # Prevents print statement every time an endpoint is triggered. logging.getLogger("werkzeug").setLevel(logging.DEBUG) #logging.getLogger("werkzeug").setLevel(logging.WARNING) APP.register_blueprint(ERRORS) APP.register_blueprint(ROUTES, url_prefix="/otf/vth/oran/a1/v1") if __name__ == '__main__': LOG_HANDLER = FileHandler('a1-policy-manager.log', mode='a') LOG_HANDLER.setLevel(logging.INFO) LOG.setLevel(logging.INFO) LOG.addHandler(LOG_HANDLER) #context = ('opt/cert/otf.pem', 'opt/cert/privateKey.pem') # app.run(debug = False, host = '0.0.0.0', port = 5000, ssl_context = context) APP.run(debug=False, host='0.0.0.0', port=6000)
from flask import Flask, request, jsonify
from flask.logging import create_logger
import logging
import pandas as pd
from sklearn.externals import joblib
from sklearn.preprocessing import StandardScaler
app = Flask(__name__)
LOG = create_logger(app)
LOG.setLevel(logging.INFO)
def scale(payload):
"""Scales Payload"""
LOG.info(f"Scaling Payload: \n{payload}")
scaler = StandardScaler().fit(payload.astype(float))
scaled_adhoc_predict = scaler.transform(payload.astype(float))
return scaled_adhoc_predict
@app.route("/")
def home():
html = "<h3>Sklearn Prediction Home</h3>"
return html.format(format)
@app.route("/predict", methods=['POST'])
def predict():
"""Performs an sklearn prediction
Work to replace https://www.openarchives.org/Register/ValidateSite
reCaptcha support based on flask-wtf example code from
https://github.com/lepture/flask-wtf/tree/master/examples/recaptcha
"""
from flask import Flask, render_template, flash, session, redirect, url_for, logging
from wtforms import TextAreaField
from wtforms.validators import DataRequired
from flask.ext.wtf import Form
from flask.ext.wtf.recaptcha import RecaptchaField
import os.path
import uuid
app = Flask(__name__)
logger = logging.create_logger(app) #FIXME - what is best way to set this up?
cfg = 'oaipmh_validation_service.cfg'
app.config.from_pyfile(cfg+'_default') #assume default always present
app.config.from_pyfile(cfg, silent=True) #override for real config
class ValidateForm(Form):
base_url = TextAreaField("baseURL", validators=[DataRequired()])
recaptcha = RecaptchaField()
@app.route("/")
def index():
return redirect(url_for("validate"))
@app.route("/pmh/validate")
def validate(form=None):
from src.lib import exceptions
from src.lib.json import ApiJSONEncoder
from src.lib.response import ApiResponse
from src.lib.mongo import create_collections
app = Flask("app")
client = MongoClient(Config.DB_HOST, Config.DB_PORT)
db = client[Config.DB_NAME]
from src.todo.views import ListAPI, ItemAPI
from src.todo.collections import List, Item
create_collections(db, List)
create_collections(db, Item)
create_logger(app)
app.config.from_object(Config)
app.json_encoder = ApiJSONEncoder
app.response_class = ApiResponse
list_view = ListAPI.as_view('lists_api')
app.add_url_rule('/api/lists', view_func=list_view, methods=['GET', 'POST'])
app.add_url_rule('/api/lists/<string:list_id>',
view_func=list_view,
methods=['GET', 'PUT', 'DELETE'])
item_view = ItemAPI.as_view('item_api')
app.add_url_rule('/api/items', view_func=item_view, methods=['POST'])
app.add_url_rule('/api/items/<string:item_id>',
view_func=item_view,
}
Talisman(app, content_security_policy=csp)
app.config.from_pyfile(config_filename)
db.init_app(app)
app.register_blueprint(main)
register_rq_dashboard(app)
with app.app_context():
db.create_all()
return app
def register_rq_dashboard(app):
app.config.from_object(rq_dashboard.default_settings)
app.config["RQ_DASHBOARD_REDIS_URL"] = REDIS_URL
@rq_dashboard.blueprint.before_request
def requires_auth():
auth = request.authorization
if not auth or not check_auth(auth.username, auth.password):
return auth_response()
app.register_blueprint(rq_dashboard.blueprint, url_prefix="/rq")
app = create_app("config.py")
log = create_logger(app)
def create_app(
session_manager: db.SessionManager,
allowed_domain: str,
mail: Union[mailer.SMTPMailer, mailer.PrintMailer] = mailer.PrintMailer(),
):
# pylint: disable=unused-variable
app = Flask(__name__)
logger = create_logger(app)
sm = session_manager
logger.info("Using %s for mail" % mail)
@app.route("/start/<int:user_id>/<uuid:secondary_id>",
methods=["POST", "GET"])
def start(user_id: int, secondary_id: uuid.UUID):
session = sm.session(user_id, secondary_id)
if session is None:
abort(404)
# Handle other states that shouldn't go to /start.
if session.state is db.SessionState.WAITING_ON_CODE:
return redirect_to_verify(user_id, secondary_id)
if session.state in (db.SessionState.VERIFIED,
db.SessionState.COMPLETED):
return redirect(url_for("success"), code=303)
if session.state is db.SessionState.FAILED:
return redirect(url_for("failure"), code=303)
assert session.state is db.SessionState.WAITING_ON_START
if request.method == "POST":
email_addr = request.form["email"]
if not email_addr.endswith(allowed_domain):
# TODO: error feedback
return redirect(url_for("start",
user_id=user_id,
secondary_id=secondary_id),
code=303)
logger.info(
f"User {session.discord_name} with id {session.user_id} sent an email"
)
mail.send(email_addr, session.verification_code,
session.discord_name)
sm.set_email_sent(user_id, secondary_id)
return redirect_to_verify(user_id, secondary_id)
else:
return render_template("start.html")
@app.route("/verify/<int:user_id>/<uuid:secondary_id>", methods=["POST"])
def verify_post(user_id: int, secondary_id: uuid.UUID):
# Post-Redirect-Get pattern
attempted_code: str = request.form["verification"]
verification_result = sm.verify(user_id, secondary_id, attempted_code)
if verification_result is True:
return redirect(url_for("success"), code=303)
elif verification_result == 0:
# TODO: give 400 error? But who cares
return redirect(url_for("failure"), code=303)
else:
return redirect_to_verify(user_id, secondary_id)
@app.route("/verify/<int:user_id>/<uuid:secondary_id>", methods=["GET"])
def verify_get(user_id: int, secondary_id: uuid.UUID):
session = sm.session(user_id, secondary_id)
if session is None:
abort(404)
remaining_attempts = session.remaining_attempts
if remaining_attempts is None:
abort(404)
assert remaining_attempts >= 0
# Handle other states that shouldn't go to /verify
if remaining_attempts == 0 or session.state == db.SessionState.FAILED:
return redirect(url_for("failure"), code=303)
if session.state == db.SessionState.VERIFIED:
return redirect(url_for("success"), code=303)
if session.state == db.SessionState.WAITING_ON_START:
return redirect(url_for("start",
user_id=user_id,
secondary_id=secondary_id),
code=303)
return render_template(
"verify.html",
remaining_attempts=remaining_attempts,
), 200
@app.route("/success")
def success():
response = app.make_response(
render_template("passed_verification.html"))
set_cache(response)
return response
@app.route("/failure")
def failure():
response = app.make_response(
render_template("failed_verification.html"))
set_cache(response)
return response
@app.route("/")
def root():
response = app.make_response(render_template("index.html"))
set_cache(response)
return response
@app.errorhandler(404)
def page_not_found(e):
return render_template("404.html"), 404
return app
#app = Flask(__name__)
app.config['MONGO_DBNAME'] = "foodb"
app.config[
'MONGO_URI'] = "mongodb+srv://admin:[email protected]/foodb?retryWrites=true&w=majority"
app.config[
'SECRET_KEY'] = 'enydM2ANhdcoKwdVa0mWvEsbPFuQpMjf' # Create your own.
app.config['SESSION_PROTECTION'] = 'strong'
#mongo = PyMongo(app)
# Use Flask-Login to track current user in Flask's session.
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = 'login'
LOG = logging.create_logger(app)
mongo = PyMongo(app)
@app.route('/')
def index():
return redirect(url_for('products_list'))
@app.route('/products/')
def products_list():
"""Provide HTML listing of all Products."""
# Query: Get all Products objects, sorted by date.
products = mongo.db.products.find()[:]
return render_template('product/index.html', products=products)
import json
from flask import Flask, request, jsonify, abort
from flask.logging import create_logger
from backend.session_handler import create_session, load_session_file, save_session_file
from backend.lang.CastleVisitor import evaluate_expression
from backend.lang.structures import CastleException
application = Flask(__name__)
LOG = create_logger(application)
@application.route("/create-session", methods=["POST"])
def create():
if request.method == "POST":
session_id = create_session()
response = jsonify({"id": session_id})
response.headers.add("Access-Control-Allow-Origin", "*")
return response
else:
LOG.error("This should be a POST request")
@application.route("/get-history", methods=["POST"])
def get_history():
if request.method == "POST":
# Extract Data
"""
App initialization.
"""
import logging
from logging.handlers import SMTPHandler, RotatingFileHandler
from flask.logging import create_logger
import os
from flask import Flask
from config import Config
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
shocal = Flask(__name__)
logger = create_logger(shocal)
shocal.config.from_object(Config)
db = SQLAlchemy(shocal)
migrate = Migrate(shocal, db)
if not shocal.debug:
if shocal.config['MAIL_SERVER']:
auth = None
if shocal.config['MAIL_USERNAME'] or shocal.config['MAIL_PASSWORD']:
auth = (shocal.config['MAIL_USERNAME']
or shocal.config['MAIL_PASSWORD'])
secure = None
if shocal.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
mailhost=(shocal.config['MAIL_SERVER'],
shocal.config['MAIL_PORT']),
from flask import Flask, jsonify, request, logging
from callqueue.domain import parse_call
from callqueue.handler import WorkflowManager
from callqueue.database import InMemoryDatabase
from callqueue.queueservice import QueueService
app = Flask(__name__)
manager = WorkflowManager(InMemoryDatabase(),
QueueService(),
logger=logging.create_logger(app))
@app.route('/')
def index():
return 'Hello World!'
@app.route('/queue', methods=['POST'])
def queue_call():
body = request.json
caller = parse_call(body)
response = manager.greet_caller(caller)
return jsonify(response)
from app import ap_parser
from app.db import get_db
from app import user_handler
from app import login_handler
from app import error_handler
from werkzeug.utils import secure_filename
from flask_login import LoginManager, UserMixin, logout_user, login_user, login_required, current_user
from datetime import timedelta
import json
import os
import io
import logging
from collections import Counter
# for flask run
app.logger = create_logger(app)
# when running gunicorn
# gunicorn_logger = logging.getLogger('gunicorn.error')
# app.logger = gunicorn_logger
## API routes
# Add custom api routes here. Be careful not to overwrite other routes or route function names.
#####################################
#####################################
@app.route('/api/callAPI', methods=["POST", "OPTIONS"])
def call_api():
"""
def initlogging(app):
import logging
from logging import handlers
from . import handlers as myojin_handlers
# DEBUG flag is not True set several handler for production.
if app.config.get('LOGGING_DEBUG',
False) or not app.config.get('DEBUG', True):
if app.config.get('LOGGING_DEBUG') is True:
from flask.logging import create_logger
create_logger(app)
else:
del app.logger.handlers[:]
import socket
hostname = socket.gethostname()
log_exc_mailto = app.config.get('LOGGING_EXCEPTION_MAILTO')
if log_exc_mailto is not None:
print >> sys.stderr, "register logging handler => exception mail to %s" % log_exc_mailto
mh = myojin_handlers.MailHandler(
app.config.get('MAIL_SENDER_FROM', '*****@*****.**'),
log_exc_mailto, 'Application(%s) Failed on %s' % (
os.path.basename(app.root_path),
hostname,
))
mh.setFormatter(logging.Formatter(SMTP_LOG_FORMAT))
mh.setLevel(logging.ERROR)
app.logger.addHandler(mh)
log_filename = app.config.get('LOGGING_FILENAME', None)
if log_filename is not None:
print >> sys.stderr, "register logging handler => file to %s" % log_filename
fh = handlers.TimedRotatingFileHandler(log_filename,
when='D',
interval=1,
backupCount=2)
fh.setLevel(logging.DEBUG)
fh.setFormatter(logging.Formatter(FILE_LOG_FORMAT))
app.logger.addHandler(fh)
log_syslog_host = app.config.get('LOGGING_SYSLOG_HOST', None)
if log_syslog_host is not None:
print >> sys.stderr, "register logging handler => syslog to %s" % str(
log_syslog_host)
sh = handlers.SysLogHandler(
log_syslog_host,
app.config.get('LOGGING_SYSLOG_CATEGORY', 'local0'))
sh.setLevel(logging.DEBUG)
sh.setFormatter(logging.Formatter(SYSLOG_FORMAT))
app.logger.addHandler(sh)
request_logging = app.config.get('LOGGING_REQUEST_ENABLED', True)
if request_logging:
ignore_urls = app.config.get('LOGGING_REQUEST_IGNORE_URLS')
ignore_urls_string = " ".join(ignore_urls)
from flask import request
# setting before and after request functions
REQUEST_START_LOGGING_FORMAT = "[REQSTART][%s] %04s %s"
REQUEST_END_LOGGING_FORMAT = "[ REQEND][%s] %04s %s %s"
current_user = app.current_user
@app.before_request
def before_request_logging():
if request.url in ignore_urls_string: return
try:
app.logger.debug(
REQUEST_START_LOGGING_FORMAT %
(repr(current_user).encode('utf-8', errors="ignore")
if current_user.is_authenticated() else "anonymous",
request.method, request.path))
except:
import traceback
traceback.print_exc(file=sys.stderr)
@app.after_request
def after_request_logging(response):
if request.url in ignore_urls_string: return
try:
if response.status_code < 400:
app.logger.debug(
REQUEST_END_LOGGING_FORMAT %
(repr(current_user).encode('utf-8',
errors="ignore") if
current_user.is_authenticated() else "anonymous",
request.method, request.path,
response.status_code))
else:
app.logger.info(
REQUEST_END_LOGGING_FORMAT %
(repr(current_user).encode('utf-8',
errors="ignore") if
current_user.is_authenticated() else "anonymous",
request.method, request.path,
response.status_code))
except:
import traceback
traceback.print_exc(file=sys.stderr)
return response
# print >>sys.stderr, "app.config['DEBUG'] => %s" % app.config.get('DEBUG')
# print >>sys.stderr, "app.config['LOGGING_LEVEL'] => %s" % app.config.get('LOGGING_LEVEL')
app.logger.setLevel(app.config.get('LOGGING_LEVEL', logging.DEBUG))
print >> sys.stderr, "app.logger.effective_level: %s" % (
logging.getLevelName(app.logger.getEffectiveLevel()))
print >> sys.stderr, "app.logger.handlers: %s" % (app.logger.handlers)
print >> sys.stderr, "app.logger initialized."
def before_request():
"""
リクエストの前処理
"""
logger = logging.create_logger(current_app)
logger.info(f"start {current_app.name} :: {request.json}")
import json
import logging
from pathlib import Path
from typing import Dict
import markdown
from flask import render_template
from flask.logging import create_logger
from flask.templating import render_template_string
from app import app
from app.constants import BLOG_POST_DIRECTORY, NOTEBOOK_DIRECTORY, STATIC_DIRECTORY
logging.basicConfig(level=logging.INFO)
LOGGER = create_logger(app)
HTML = str
def extend_base_template(*args, **kwargs):
"""
Passes all of the kwargs required by the base template,
then continues with rendering the template
"""
tab_contents = [
{
"name": "Home",
"route": "/"
},
