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