def wrap(app, rule): """Wrap flask app with rule based request rate control. """ limiter = flask_limiter.Limiter( app, key_func=flask_limiter.util.get_remote_address, ) limit_value = rule.pop('_global', None) if limit_value is not None: decorator = limiter.shared_limit(limit_value, scope='_global') for endpoint, func in app.view_functions.items(): app.view_functions[endpoint] = decorator(func) if rule: decorators = { module: limiter.shared_limit(limit_value, scope=module) for module, limit_value in rule.items() } for endpoint, func in app.view_functions.items(): module = None if hasattr(func, 'view_class'): module = func.__module__.rsplit('.')[-1] if module in decorators: decorator = decorators[module] app.view_functions[endpoint] = decorator(func) return app
def _init_rate_limiter() -> flask_limiter.Limiter: # Ask the config if the http header or the actual ip address # should be used, when identifying users for rate limiting. if app.config.get("RATE_LIMITING_USE_X_FORWARDED_FOR"): key_func = flask_limiter.util.get_ipaddr else: key_func = flask_limiter.util.get_remote_address return flask_limiter.Limiter(app, key_func=key_func)
def wrap(app, rule): """Wrap flask app with rule based request rate control. """ limit_by = rule.pop('_limit_by', None) limiter = flask_limiter.Limiter( app, key_func=_get_key_func(limit_by=limit_by), ) limit_value = rule.pop('_global', None) if limit_value is not None: decorator = limiter.shared_limit(limit_value, scope='_global') for endpoint, func in app.view_functions.items(): # A shared rate limit could be evaluated multiple times for single # request, because `flask_limiter` uses # "func.__module__ + func.__name__" as key format to differentiate # non Blueprint routes. # # For example, both cases blow register to the same key format as # "flask.helpers.send_static_file" # 1. `restful_plus` static file requests (i.e. "/swaggerui/ui.js"). # 2. default static file endpoint registration of # `treadmill.rest.FLASK_APP`, because param "static_folder" in # constructer has its default value. # # so each request of hitting "flask.helpers.send_static_file" will # increase rate limit counter by 2 (which 1 is expectation). A # workaround here is only concerning about `treadmill.rest.api` # resources. if hasattr(func, 'view_class'): app.view_functions[endpoint] = decorator(func) if rule: decorators = { module: limiter.shared_limit(limit_value, scope=module) for module, limit_value in rule.items() } for endpoint, func in app.view_functions.items(): module = None if hasattr(func, 'view_class'): module = func.__module__.rsplit('.')[-1] if module in decorators: decorator = decorators[module] app.view_functions[endpoint] = decorator(func) return app
'HOST_SMTP': 'smtp', 'HOST_WEBMAIL': 'webmail', 'HOST_FRONT': 'front', 'HOST_AUTHSMTP': os.environ.get('HOST_SMTP', 'smtp'), 'POD_ADDRESS_RANGE': None } # Load configuration from the environment if available for key, value in default_config.items(): app.config[key] = os.environ.get(key, value) # Base application flask_bootstrap.Bootstrap(app) db = flask_sqlalchemy.SQLAlchemy(app) migrate = flask_migrate.Migrate(app, db) limiter = flask_limiter.Limiter(app, key_func=lambda: current_user.username) # Debugging toolbar if app.config.get("DEBUG"): import flask_debugtoolbar toolbar = flask_debugtoolbar.DebugToolbarExtension(app) # Profiler if app.config.get("DEBUG"): app.wsgi_app = profiler.ProfilerMiddleware(app.wsgi_app, restrictions=[30]) # Manager commnad manager = flask_script.Manager(app) manager.add_command('db', flask_migrate.MigrateCommand) # Babel configuration
from werkzeug.utils import secure_filename import os, sys, json, secrets, copy, io import rede_config as config, rede_relacionamentos import pandas as pd from requests.utils import unquote import rede_config as config try: #define alguma atividade quando é chamado por /rede/envia_json, função serve_envia_json_acao import rede_acao except: pass app = Flask("rede") limiter = flask_limiter.Limiter(app, key_func=flask_limiter.util.get_remote_address) #, default_limits=["200 per day", "50 per hour"]) limiter_padrao = config.config['ETC'].get('limiter_padrao', '20/minute').strip() limiter_dados = config.config['ETC'].get('limiter_dados', limiter_padrao).strip() #https://blog.cambridgespark.com/python-context-manager-3d53a4d6f017 gp = {} gp['numeroDeEmpresasNaBase'] = rede_relacionamentos.numeroDeEmpresasNaBase() gp['camadaMaxima'] = 10 #como é usada a tabela tmp_cnpjs no sqlite para todas as consultas, se houver requisições simultâneas ocorre colisão. #o lock faz esperar terminar as requisições por ordem. #no linux, quando se usa nginx e uwsgi, usar lock do uwsgi, senão lock do threading (funciona no linux quando só tem 1 worker) import contextlib try: import uwsgi #supondo que quando tem uwsgi instalado, está usando linux e nginx gUwsgiLock=True
os.system("title ClassCompanion Host") def getDatabase(): return mysql.connector.connect( host = "localhost", user = os.environ.get("MySQL_username"), passwd = os.environ.get("MySQL_password"), database = "ClassCompanion" ) app = flask.Flask(__name__, template_folder = ".") #, static_folder = "resources/") # using cdn from nginx def get_remote_address(): return flask.request.headers.get("X-Real-IP") # Using proxy_pass in nginx & setting header for real ip. limiter = flask_limiter.Limiter(app, key_func = get_remote_address) project = { "name": "Class Companion", "website": "https://classcompanion.us.to/", "host": "classcompanion.us.to", "ip": "0.0.0.0", "port": 1516 } @app.route("/", methods = ["GET"]) @limiter.limit("5/second") def index(): args = flask.request.args data = flask.request.get_data(as_text = True) headers = flask.request.headers
'CACHE_THRESHOLD': 25000, 'CACHE_DEFAULT_TIMEOUT': 60, }) # Setup openid oid = flask_openid.OpenID(app) # Setup database connection db = flask_sqlalchemy.SQLAlchemy(app) from .models import User, Team, GameServer, Match, Tournament, MapStats, PlayerStats # noqa: E402 migrate = flask_migrate.Migrate(app, db) # Setup rate limiting limiter = flask_limiter.Limiter( app, key_func=flask_limiter.util.get_remote_address, default_limits=['250 per minute'], ) # Setup logging formatter = logging.Formatter( '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s') if 'LOG_PATH' in app.config: file_handler = logging.handlers.TimedRotatingFileHandler( app.config['LOG_PATH'], when='midnight') file_handler.setLevel(logging.INFO) file_handler.setFormatter(formatter) app.logger.addHandler(file_handler) stream_handler = logging.StreamHandler(sys.stdout) stream_handler.setLevel(logging.INFO)
import botocore import uuid import urllib.parse import urllib.request import json import os from flask import Flask import flask import flask_limiter import flask_limiter.util from jinja2 import Template from werkzeug.contrib.fixers import ProxyFix app = Flask(__name__) limiter = flask_limiter.Limiter(app, key_func=flask_limiter.util.get_remote_address, storage_uri=os.getenv( 'UPLOAD_RATE_LIMIT_STORAGE', 'memory://'), key_prefix="rate_limiter:") S3_UPLOAD_GRACE_PERIOD = 10 DEFAULT_SERVICE_NAME = 'Simple Python S3 File Hosting' DEFAULT_UPLOAD_REMARKS = '' DEFAULT_RESULT_REMARKS = '' DEFAULT_BACKEND_NAME = '[backend name]' DEFAULT_HOSTER_NAME = '[hoster name]' DEFAULT_CONTACT_EMAIL = '[contact name]' def get_s3_current_servicec_provider_envvar(var, default=''): return os.getenv(f"S3_{os.getenv('S3_CURRENT_SERVICE_PROVIDER')}_{var}", default)
import requests # Local from . import models from . import config # Flask setup app = flask.Flask(__name__) config_path = os.path.dirname(os.path.abspath(__file__)) app.config.from_pyfile(os.path.join(config_path, "config.py")) app.register_blueprint(sse, url_prefix='/stream') api = flask_restful.Api(app, catch_all_404s=True) limiter = flask_limiter.Limiter( app, key_func=(flask_limiter.util. get_remote_address), global_limits=config.LIMITS_GLOBAL ) db = flask_sqlalchemy.SQLAlchemy(app) auth = HTTPBasicAuth() class User(flask_restful.Resource): """User account resource; manage users in the system. """ SCHEMA_POST = { "type": "object", "properties": {
configuration.initialize() process_emails.initialize() basic_auth = fh.HTTPBasicAuth() token_auth = fh.HTTPTokenAuth() app = FlaskApp(__name__) CORS(app, supports_credentials=True, resources={r'*': { 'origins': configuration.application_link }}) api = fr.Api(app) # Limit the number of requests that can be made in a certain time period limiter = fl.Limiter( app, key_func=fl.util.get_remote_address, default_limits=['5 per second', '50 per minute', '1000 per day']) @basic_auth.error_handler @token_auth.error_handler def unauthorized(): """The response of the server when getting unauthorized.""" return flask.make_response('Unauthorized Access', 403) # Should be 503 @basic_auth.verify_password def verify_login_credentials(username, password): """ Verify if the credentials are valid.
"""Contains of flask extensions.""" import flasgger import flask_limiter import flask_migrate import flask_sqlalchemy __all__ = [ 'database', 'limiter', 'migrate', 'swagger', ] database = flask_sqlalchemy.SQLAlchemy() limiter = flask_limiter.Limiter(key_func=flask_limiter.util.get_remote_address) migrate = flask_migrate.Migrate() swagger = flasgger.Swagger()
import flask_assets import flask_limiter import flask_login import flask_mail import flask_sqlalchemy assets = flask_assets.Environment() db = flask_sqlalchemy.SQLAlchemy() limiter = flask_limiter.Limiter() login_manager = flask_login.LoginManager() mail = flask_mail.Mail()
def __init(self, instance): instance.config.from_envvar('FLASK_SETTING') self.settings = instance.config if instance.debug: current = os.path.dirname(__file__) self.path = os.path.join(current, '..', 'dump', 'data') self.lpath = os.path.join(current, '..', 'dump', 'logs') else: self.path = os.path.join('/', 'var', 'rere1') self.lpath = os.path.join('/', 'var', 'logs') instance.wsgi_app = \ werkzeug.contrib.fixers.ProxyFix(instance.wsgi_app) self.sentry = raven.contrib.flask.Sentry( instance, logging=True, level=logging.WARNING, ) const = base.Constant with instance.app_context(): for _ in range(0, self.settings[const.SETTING_MAX_RECONNECTION_TRY]): try: self.db = base.Alchemy self.db.init_app(instance) self.db.create_all() self.db.session.commit() break except Exception as exception: time.sleep(self.settings[const.SETTING_DEFAULT_SLEEP_TIME]) self.redis = flask_redis.FlaskRedis() self.redis.init_app(instance, decode_responses=True) for _ in range(0, self.settings[const.SETTING_MAX_RECONNECTION_TRY]): try: if self.redis.ping(): break else: raise Exception() except Exception as exception: time.sleep(self.settings[const.SETTING_DEFAULT_SLEEP_TIME]) flask_cors.CORS(instance) self.extensions = {} self.extensions['mail'] = flask_mail.Mail() self.extensions['mail'].init_app(instance) remote = flask_limiter.util.get_remote_address self.extensions['limiter'] = flask_limiter.Limiter(key_func=remote) self.extensions['limiter'].init_app(instance) self.extensions['cache'] = flask_cache.Cache(with_jinja2_ext=False) self.extensions['cache'].init_app(instance) if not instance.debug: for name, exception in werkzeug.exceptions.__dict__.items(): if isinstance(exception, type): if issubclass(exception, Exception): instance.register_error_handler( exception, lambda exception: flask.jsonify({}), ) if not instance.debug: instance.logger.removeHandler(flask.logging.default_handler) handler = logging.FileHandler(os.path.join(self.lpath, 'api.log'), ) handler.setLevel(logging.WARNING) instance.logger.addHandler(handler) self.__components = {} for name, component in components.__dict__.items(): if isinstance(component, type): if issubclass(component, base.Component): self.__components[name.lower()] = component(self) self.__actions = {} for name, action in actions.__dict__.items(): if isinstance(action, type): if issubclass(action, base.Action): self.__actions[name.lower()] = action(self) for name, command in commands.__dict__.items(): if isinstance(command, type): if issubclass(command, base.Command): cmd = functools.partial(command.execute, command(self)) cmd.__name__ = command.NAME cmd = click.command()(cmd) cmd.short_help = command.DESCRIPTION for argument in command.ARGUMENTS: cmd = click.option( '--' + argument['name'], type=argument['type'], default=argument['default'], help=argument['description'], )(cmd) instance.cli.add_command(cmd)
from flask_limiter import util import flask_sqlalchemy import num2words import os from sqlalchemy.sql import func from us import states app = flask.Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = flask_sqlalchemy.SQLAlchemy(app) limiter = flask_limiter.Limiter(app, key_func=util.get_remote_address, default_limits=[ "200 per day", "60 per hour", "10 per minute", "2 per second" ]) class CommentData(db.Model): id = db.Column(db.BigInteger, primary_key=True) state_fips = db.Column(db.String(2), index=True) district_fips = db.Column(db.String(2), index=True) name = db.Column(db.String) city = db.Column(db.String) comment = db.Column(db.String) @app.route('/') def index():
from werkzeug.middleware.proxy_fix import ProxyFix from tasks.process_image import process_image from tasks.roll_and_take_image import roll_and_take_image app = Flask(__name__) flask_cors.CORS( app) # This lets us access the API from different domains/websites # If you are running behind a reverse-proxy like Caddy/Nginx, set this to true, to get *real* client's addresses if bool(os.getenv('FLASK_REVERSE_PROXY')): app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1) # Rate limiter to prevent spam/overloading stuff limiter = flask_limiter.Limiter( app, key_func=flask_limiter.util.get_remote_address, default_limits=["10/second"], headers_enabled= True, # Send headers with info about how much time has left until unlocking ) # Premium users who can spam as much as they want # That is - me :) premium_passwords = [] _p_pass_file = pathlib.Path('premium_passwords.txt') if _p_pass_file.exists(): with open(_p_pass_file, 'r') as f: premium_passwords = f.read().split() # Main API endpoint - change this if anything big changes, or features/endpoints are removed API1 = '/api/' _redis = redis.Redis()
# from hikka.modules import anime # from hikka.modules import teams from hikka.modules import auth from flask_cors import CORS import flask_limiter import mongoengine import config app = Flask(__name__) app.config["SECRET_KEY"] = config.secret app.config["JSON_SORT_KEYS"] = False CORS(app) limiter = flask_limiter.Limiter( app=app, key_func=get_remote_address, default_limits=config.limits ) db_settings = dict( username=config.db["username"], password=config.db["password"], port=config.db["port"] ) mongoengine.register_connection( alias="default", name=config.db["name"], **db_settings )