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
)
