import logging
import redis
# redis credentials
redis_host = environ.get("REDIS_HOST")
redis_port = environ.get("REDIS_PORT")
redis_pass = environ.get("REDIS_PASS")
red = redis.StrictRedis(host=redis_host,
port=redis_port,
password=redis_pass,
charset="utf-8",
decode_responses=True)
app = Flask(__name__)
limiter = Limiter(app,
key_func=get_remote_address,
storage_uri="redis://:%s@%s:%s" %
(redis_pass, redis_host, redis_port))
log = logging.getLogger(__name__)
json_ct = {'Content-Type': 'application/json'}
def error_handler():
return app.config.get("DEFAULT_ERROR_MESSAGE")
# scan profile batch
@app.route("/api/scan/batch")
def api_scan_batch():
# internal gae header
if request.headers.get('X-Appengine-Cron'):
try:
"googleads.g.doubleclick.net",
"watcher.risd.net",
"*",
],
}
app = Flask(__name__)
Talisman(
app,
content_security_policy={},
content_security_policy_report_only=True,
content_security_policy_report_uri=REPORT_URI,
)
limiter = Limiter(app,
key_func=get_remote_address,
default_limits=["200 per day", "50 per hour"])
log_level = logging.getLevelName(LOG_LEVEL)
app.logger.setLevel(log_level)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
app.secret_key = FLASK_SECRET_KEY
app.config.from_pyfile("config.py")
app.config.update(
CELERY_ACCEPT_CONTENT=["pickle", "json"],
CELERY_ALWAYS_EAGER=False,
CELERY_IMPORTS=("app", "npsp", "batch"),
)
from flask_debugtoolbar import DebugToolbarExtension from flask_mail import Mail from flask_wtf import CSRFProtect from flask_sqlalchemy import SQLAlchemy from flask_login import LoginManager from flask_limiter import Limiter from flask_limiter.util import get_remote_address from flask_babel import Babel from flask_static_digest import FlaskStaticDigest debug_toolbar = DebugToolbarExtension() mail = Mail() csrf = CSRFProtect() db = SQLAlchemy() login_manager = LoginManager() limiter = Limiter(key_func=get_remote_address) babel = Babel() flask_static_digest = FlaskStaticDigest()
# User account references
login = LoginManager(app)
login.login_view = 'login'
# Mail settings
mail = Mail(app)
# Bootstrap references
bootstrap = Bootstrap(app)
# flask-moment references
moment = Moment(app)
# flask-limiter references
limiter = Limiter(app)
# Import app for rest of module
from app import routes, models, errors
# Error handling
if not app.debug and not app.testing:
# Email alert settings
if app.config['MAIL_SERVER']:
auth = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
secure = None
if app.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
from mycodo.utils.database import db_retrieve_table
from mycodo.utils.image import generate_thermal_image_from_pixels
from mycodo.utils.influx import influx_time_str_to_milliseconds
from mycodo.utils.influx import query_string
from mycodo.utils.system_pi import assure_path_exists
from mycodo.utils.system_pi import return_measurement_info
from mycodo.utils.system_pi import str_is_float
blueprint = Blueprint('routes_general',
__name__,
static_folder='../static',
template_folder='../templates')
logger = logging.getLogger(__name__)
limiter = Limiter(key_func=get_ip_address)
@blueprint.route('/')
def home():
"""Load the default landing page"""
if flask_login.current_user.is_authenticated:
if flask_login.current_user.landing_page == 'live':
return redirect(url_for('routes_page.page_live'))
elif flask_login.current_user.landing_page == 'dashboard':
return redirect(url_for('routes_page.page_dashboard_default'))
return redirect(url_for('routes_page.page_live'))
return clear_cookie_auth()
@blueprint.route('/settings', methods=('GET', 'POST'))
self.timer.start()
def stop(self):
print "stop"
self.timer.cancel()
def defaultHandler(self):
print "defaultHandler"
raise self
app = Flask(__name__)
api = Api(app)
limiter = Limiter(
app,
key_func=get_remote_address,
swallow_errors=True,
default_limits=[sys.argv[1] + " per minute"] # n param from cmd
)
lock = threading.Lock()
def myHandler():
print("handler")
with lock:
if (Pictures.updeted == False):
open(UPLOAD_FOLDER + '\statistics.txt',
"a").write(Pictures.str2save)
Pictures.updeted = True
print Pictures.str2save
import flask
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
import knockknock.hibp
import knockknock.auth
import knockknock.config
from knockknock.ldap import LDAPClient
from ldap3.core.exceptions import LDAPException
import logging
logger = logging.getLogger(__name__)
app = flask.Flask(__name__)
limiter = Limiter(app, key_func=get_remote_address, default_limits=["10 per second"])
# Only allow one request per user per second on the authentication endpoints.
limiter.limit("1 per second")(knockknock.auth.bp)
app.register_blueprint(knockknock.auth.bp)
# app.config.update(
# SESSION_COOKIE_SECURE=True,
# SESSION_COOKIE_SAMESITE="Strict",
# )
config = knockknock.config.Config("../../etc/config.ini")
def get_active_config():
return config
@app.route("/")
def main_page():
"""Render the main page.
def extension_limiter(app):
limiter = Limiter(app, key_func=get_key_func, headers_enabled=True)
limiter.limit("300/hour")(routes_authentication.blueprint)
limiter.limit("20/hour")(routes_password_reset.blueprint)
limiter.limit("200/minute")(api_blueprint)
return app
from flask import Flask, request, send_file
from flask_limiter import Limiter
from PIL import Image, ImageOps
from style_transfer import stylize_img
from ga import track_event
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 1024 * 1024 * 8
limiter = Limiter(app, default_limits=['1 per second'])
@app.route('/transfer', methods=['POST'])
def transfer():
track_event(category='Style_Transfer', action='transfer')
if not request.files.get('base_image'):
return {'error': 'must have a base image'}, 400
if not request.files.get('style_image'):
return {'error': 'must have a style image'}, 400
try:
base_image = Image.open(request.files['base_image'].stream)
style_image = Image.open(request.files['style_image'].stream)
if (base_image.format not in ['JPG', 'JPEG', 'PNG']):
return {'error': 'image must be jpg, jpeg or png'}, 400
if (style_image.format not in ['JPG', 'JPEG', 'PNG']):
return {'error': 'image must be jpg, jpeg or png'}, 400
def app_path(path):
"""
Get a path next to the Flask app directory, where static files and
templates may be.
"""
return os.path.join(os.path.dirname(app.root_path), path)
app.config['RATELIMIT_ENABLED'] = os.environ.get(
'CONCEPTNET_RATE_LIMITING') == '1'
for filter_name, filter_func in FILTERS.items():
app.jinja_env.filters[filter_name] = filter_func
limiter = Limiter(app, global_limits=["600 per minute", "6000 per hour"])
try_configuring_sentry(app)
application = app # for uWSGI
def get_int(args, key, default, minimum, maximum):
strvalue = args.get(key, default)
try:
value = int(strvalue)
except ValueError:
value = default
return max(minimum, min(maximum, value))
# Lookup: match any path starting with /a/, /c/, /d/, /r/, or /s/
# @app.route('/<any(a, c, d, r, s):top>/<path:query>')
from flask_admin import Admin, AdminIndexView
from flask_mongoengine import MongoEngine
from flask import Flask, url_for, redirect, render_template, request, make_response
from werkzeug.security import generate_password_hash, check_password_hash
from wtforms import form, fields, validators
from flask_restful import Resource
import flask_login as login
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from flask_admin.contrib.mongoengine import ModelView
import redis
r = redis.StrictRedis("localhost", 6379, db=0)
limiter = Limiter(
key_func=get_remote_address, # 根据访问者的IP记录访问次数
# default_limits=["7 per day"]
)
db = MongoEngine()
class AdminUser(db.Document):
username = db.StringField(max_length=80, unique=True)
email = db.StringField(max_length=120)
password = db.StringField()
meta = {'db_alias': 'home'}
# Flask-Login integration
# NOTE: is_authenticated, is_active, and is_anonymous
# are methods in Flask-Login < 0.3.0
@property
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from util import get_config, get_log, limit_content_length
app = Flask(__name__)
# get configuration
conf = get_config("configs.yaml")
MAX_CONTENT_LENGTH = conf["config"]["MAX_CONTENT_LENGTH"]
# implement rate limit
limiter = Limiter(app,
key_func=get_remote_address,
default_limits=[
conf["config"]["limiter"]["day"],
conf["config"]["limiter"]["hour"],
conf["config"]["limiter"]["second"],
])
# get logger
logobj = get_log()
@app.route('/sorting', methods=['POST'])
@limit_content_length(MAX_CONTENT_LENGTH)
def sort_list():
"""
This route receives a list of int numbers as data, and an order for sorting
:return: return a sorted list of data consisting of integer numbers
"""
from flask import Flask, request
from flask_login import current_user
from flask_restful import Resource, Api, abort, reqparse, fields, marshal_with
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
import pymongo
from pymongo.bulk import ObjectId
from flask_httpauth import HTTPBasicAuth
auth = HTTPBasicAuth()
mongo_client = pymongo.MongoClient()
app = Flask(__name__)
api = Api(app)
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=['1/day'],
)
def special_limit():
tp = request.args.get('type', None)
if tp == 'vip':
return '1/minute'
elif tp == 'svip':
return '30/second'
else:
return '1/day'
class APISchema():
import time
import os
import sys
import re
reload(sys)
sys.setdefaultencoding("utf-8")
#######flask
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
app.secret_key = os.path.join(config_dir, 'PyOne' + GetConfig('password'))
cache = Cache(app, config={'CACHE_TYPE': 'redis'})
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=["200/minute", "50/second"],
)
################################################################################
###################################功能函数#####################################
################################################################################
def md5(string):
a = hashlib.md5()
a.update(string.encode(encoding='utf-8'))
return a.hexdigest()
def GetTotal(path='A:/'):
key = 'total:{}'.format(path)
# Create Flask APP
app = Flask(__name__)
app.config.from_object(__name__)
app.config.update(dict(
DATABASE=os.path.join(app.root_path, config['apisrv']['database']),
SQLALCHEMY_DATABASE_URI='sqlite:///' + \
os.path.join(app.root_path, config['apisrv']['database']),
SQLALCHEMY_TRACK_MODIFICATIONS=False,
))
# Auth module
auth = HTTPBasicAuth()
# Database module
db = SQLAlchemy(app)
# Apply Rate limiting
limiter = Limiter(app, key_func=get_remote_address, global_limits=flask_limits)
# Not Required with SQLAlchemy
# @app.teardown_appcontext
# def close_db(error):
# """Closes the database again at the end of the request."""
# db.remove()
# Safe circular imports per Flask guide
import apisrv.errors
import apisrv.views
import apisrv.user
outputFrame = None
lock = threading.Lock()
vs = VideoStream(src=0).start()
time.sleep(2.0)
# start flask app
app = Flask(__name__)
# config flask secret key
app.config.update(SECRET_KEY=config.SECRET_KEY #"secretxxx"
)
# config flask limmiter
limiter = Limiter(
app,
key_func=get_remote_address,
)
# flask-login
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"
# silly user model
class User(UserMixin):
def __init__(self, id):
self.id = id
def __repr__(self):
return "%d" % (self.id)
from .modules import mod_restore as restore
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
logger = logging.getLogger(config.APPLICATION)
logger.setLevel(config.APPLICATION_LOG_LEVEL)
logger.addHandler(
logstash.TCPLogstashHandler(config.LOGSTASH_HOST,
config.LOGSTASH_PORT,
version=1))
try:
application = Flask(config.APPLICATION)
limiter = Limiter(application,
key_func=get_remote_address,
default_limits=[
config.APPLICATION_LIMIT_PER_MIN,
config.APPLICATION_LIMIT_PER_SEC
],
headers_enabled=True,
storage_uri=config.APPLICATION_LIMIT_STORAGE_URI)
"""
@api {post} /registration/s1 Register new user (Step 1)
@apiName Registration (Step 1)
@apiGroup Access API
@apiDescription Providing first-step registration process
@apiPermission user
@apiParam {String} phone User phone
@apiSuccess {Number} status HTTP 201 Created
@apiSuccess {Object[]} message Provision of a code to confirm registration
@apiSuccessExample Success-Response
HTTP/1.1 201 Created
def get_return_dict():
return {"format": "0.1"}
global_address = "http://%s:%d"%(PATHS['flask_host'], PATHS['flask_port'])
global_address = ""
if global_address != "" and host_interfix != "":
global_address += "/"
global_address += host_interfix
host_path = global_address
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=["%d per minute"%max_req_per_min]
)
print ([max_req_per_min, max_req_per_sec])
def split_dict_by(in_dict, split_keys = ["dataset", "cellType"]):
ret = {}
num_entries = max([len(in_dict[k]) if in_dict[k] is not None else 1 for k in in_dict])
for row in range(num_entries):
ret_subobj = ret
for split_key in split_keys:
key_value = in_dict[split_key][row]
if key_value not in ret_subobj:
ret_subobj[key_value] = {}
self.limiter.limiter.get_window_stats(lim, *args)[0]
for lim in self.limits)
return timedelta(seconds=reset - int(time.time()))
def __repr__(self):
limits = '; '.join(
str(lim)
for lim in self.limits) if self.limits is not None else 'unlimited'
return f'<RateLimit({self.scope}): {limits}>'
def make_rate_limiter(scope, limits):
"""Create a rate limiter.
Multiple limits can be separated with a semicolon; in that case
all limits are checked until one succeeds. This allows specifying
a somewhat strict limit, but then a higher limit over a longer period
of time to allow for bursts.
"""
limits = list(parse_many(limits)) if limits is not None else None
return RateLimit(limiter, limiter._key_func, scope, limits)
def _limiter_key():
return request.remote_addr if has_request_context() else 'dummy.ip'
limiter = Limiter(key_func=_limiter_key,
strategy='moving-window',
auto_check=False)
def _limiter_key_func() -> None: # pragma: no cover
"""This is the default key function for the limiter.
The key function should be set locally at every place the limiter is used
so this function always raises a :py:exc:`ValueError`.
"""
raise ValueError('Key function should be overridden')
def _limiter_deduct_when(response: Response) -> bool:
return response.status_code >= 400
_LIMITER = Limiter(key_func=_limiter_key_func,
default_limits_deduct_when=_limiter_deduct_when)
def init_app(app: 'PsefFlask') -> None:
"""Initialize rate limiting for the given app.
"""
def _handle_rate_limit_exceeded(
_: RateLimitExceeded) -> JSONResponse[errors.APIException]:
return JSONResponse.make(
errors.APIException(
'Rate limit exceeded, slow down!',
'Rate limit is exceeded',
errors.APICodes.RATE_LIMIT_EXCEEDED,
429,
),
429,
# login only if the user hasn't logged in yet
if not current_user.is_authenticated:
login_user(req.user)
return f(*args, **kwargs)
return decorated
return wrapper
oauth = OAuthProvider(app)
api = Api(app)
limiter = Limiter(
app,
key_func=get_ipaddr,
headers_enabled=True,
default_limits=[
"40 per second", # burst: 40/sec
"1440 per minute", # allowed max: 24/sec
])
if app.config.get("LOAD_TEST"):
limiter.enabled = False
DATABASE_URL = app.config.get("DATABASE_URL")
# TODO: implement connection factory
db_url.register_database(PgDbWithFailover, "pg+failover", "postgres+failover")
# db_url.PostgresqlDatabase = ReconnectablePostgresqlDatabase
if DATABASE_URL.startswith("sqlite"):
db = db_url.connect(DATABASE_URL, autorollback=True)
else:
db = db_url.connect(DATABASE_URL, autorollback=True, connect_timeout=3)
# Mail
mail = Mail()
# Caching
cache = Cache()
# Redis
redis_store = FlaskRedis()
# Debugtoolbar
debugtoolbar = DebugToolbarExtension()
# Migrations
alembic = Alembic()
# Themes
themes = Themes()
# Babel
babel = Babel()
# CSRF
csrf = CSRFProtect()
# Rate Limiting
limiter = Limiter(auto_check=False, key_func=get_remote_address)
# Celery
celery = Celery("flaskbb")
app.config["CACHE_DEFAULT_TIMEOUT"]=60
app.config["CACHE_KEY_PREFIX"]="flask_caching_"
Markdown(app)
cache=Cache(app)
Compress(app)
app.config["RATELIMIT_STORAGE_URL"]=environ.get("REDIS_URL")
app.config["RATELIMIT_KEY_PREFIX"]="flask_limiting_"
limiter = Limiter(
app,
key_func=get_remote_address,
default_limits=["100/minute"],
headers_enabled=True,
strategy="fixed-window"
)
#setup db
_engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
pool_size=4,
pool_use_lifo=True
)
Session=scoped_session(sessionmaker(bind=_engine))#, scopefunc=lambda:request)
#a_session=Session()
Base = declarative_base()
if redis_url.path:
redis_db = redis_url.path[1]
else:
redis_db = 0
# Redis passwords might be quoted with special characters
redis_password = redis_url.password and urllib.unquote(
redis_url.password)
client = redis.StrictRedis(host=redis_url.hostname,
port=redis_url.port,
db=redis_db,
password=redis_password,
ssl=use_ssl)
return client
setup_logging()
redis_connection = create_redis_connection()
mail = Mail()
migrate = Migrate()
statsd_client = StatsClient(host=settings.STATSD_HOST,
port=settings.STATSD_PORT,
prefix=settings.STATSD_PREFIX)
limiter = Limiter(key_func=get_ipaddr, storage_uri=settings.LIMITER_STORAGE)
from flask_limiter.util import get_remote_address
from flask_login import LoginManager
from flask_mail import Mail
from flask_migrate import Migrate
from flask_sitemap import Sitemap
from .config import config
bootstrap = Bootstrap()
mail = Mail()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
limiter = Limiter(key_func=get_remote_address,
default_limits=["100 per minute", "5 per second"])
sitemap = Sitemap()
def create_app(config_name='default'):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
from .models import db # noqa
bootstrap.init_app(app)
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
limiter.init_app(app)
app.config['SQLALCHEMY_DATABASE_URI'] = DB_BASE_URL + "/" + DB_NAME
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_POOL_SIZE'] = 100
app.config['SQLALCHEMY_POOL_RECYCLE'] = 280
db = SQLAlchemy(app)
CORS(app)
# ======================================================================
# ====== API SETUP ======
# Rate limiter to prevent abuse and runaway Cloud usage; per IP Address
limiter = Limiter(app,
key_func=get_ipaddr,
default_limits=["2000 per minute", "30000 per hour"])
# Default error handling messages
@app.errorhandler(404)
def errorHandler(e):
return jsonify({"type": "error", "message": "Address not found."}), 404
@app.errorhandler(405)
def methodNotAllowedHandler(e):
return jsonify({"type": "error", "message": "Method not allowed."}), 405
@app.errorhandler(429)
quokka_app = Flask(__name__)
CORS(quokka_app)
api = Api(quokka_app, version="1.0", title="Quokka", description="Quokka for 52-weeks-of-python",
default="quokka", default_label="")
ApiModels.set_api_models(api)
from db_apis import get_all_hosts, set_host, get_host, get_host_status, get_host_status_summary
from db_apis import get_all_devices, set_device, get_device, get_device_status, get_device_status_summary
from db_apis import get_all_services, set_service, get_service, get_service_status, get_service_status_summary
from db_apis import get_capture, get_portscan, get_traceroute
from db_apis import record_portscan_data, record_traceroute_data, record_capture_data, record_snoop_data
from worker_apis import start_portscan, start_traceroute, start_capture, start_snoop
limiter = Limiter(quokka_app, key_func=get_remote_address)
# Start background DB hourly task
db_hourly_task = DbHourlyTask()
db_hourly_task_thread = threading.Thread(target=db_hourly_task.start)
db_hourly_task_thread.start()
# shutdown of our flask process requires terminating background db thread
def shutdown():
db_hourly_task.set_terminate()
db_hourly_task_thread.join()
atexit.register(shutdown) # causes shutdown() to get called when exiting
import psef.models # pylint: disable=unused-import
current_user: '******' = None
else:
current_user = flask_jwt.current_user # pylint: disable=invalid-name
def limiter_key_func() -> None: # pragma: no cover
"""This is the default key function for the limiter.
The key function should be set locally at every place the limiter is used
so this function always raises a :py:exc:`ValueError`.
"""
raise ValueError('Key function should be overridden')
limiter = Limiter(key_func=limiter_key_func) # pylint: disable=invalid-name
def create_app(config: t.Mapping = None, skip_celery: bool = False) -> t.Any:
"""Create a new psef app.
:param config: The config mapping that can be used to override config.
:param skip_celery: Set to true to disable sanity checks for celery.
:returns: A new psef app object.
"""
resulting_app = Flask(__name__)
@resulting_app.before_request
def __set_request_start_time() -> None: # pylint: disable=unused-variable
g.request_start_time = datetime.datetime.utcnow()
import time
import dateutil.parser
import argparse
from random import shuffle
import re
import os
# database configuration
DATABASE = 'as.db'
if os.path.isfile('secret_key.txt'):
SECRET_KEY = open('secret_key.txt', 'r').read()
else:
SECRET_KEY = 'devkey, should be in a file'
app = Flask(__name__)
app.config.from_object(__name__)
limiter = Limiter(app, global_limits=["100 per hour", "20 per minute"])
SEARCH_DICT = {}
# -----------------------------------------------------------------------------
# utilities for database interactions
# -----------------------------------------------------------------------------
# to initialize the database: sqlite3 as.db < schema.sql
def connect_db():
sqlite_db = sqlite3.connect(DATABASE)
sqlite_db.row_factory = sqlite3.Row # to return dicts rather than tuples
return sqlite_db
@app.before_request
def before_request():
# this will always request database connection, even if we dont end up using it ;\
def create_app():
"""Factory to create the Flask application with cfg and db."""
app = Flask(__name__)
load_config(app.config)
db.init_app(app)
return app
app = create_app()
CORS(app)
oid = OpenID(app, store_factory=lambda: None)
migrate = Migrate(app, db)
limiter = Limiter(app,
key_func=get_remote_address,
default_limits=["200 per minute"])
##########
# Routes #
##########
@app.route('/docs/<path:path>')
def access_docs(path):
return send_from_directory('docs', path)
from routes.user import build_api_user
from routes.auth import build_api_auth
from routes.game import build_api_game
