class BaseHTTPService(BaseService):
template_folder = None
application_name = None
def setup_server(self):
super(BaseHTTPService, self).setup_server()
# Create an Flask application for this service using the service name
self.app = Flask(self.application_name or self.__class__.__name__, template_folder=self.template_folder or None)
methods = dir(self)
# Attach each route in the class
for name in [x for x in methods if x.startswith("route_")]:
method = getattr(self, name)
self.app.add_url_rule(method.rule, name, method)
self.logger.debug("Adding handler '%s' for '%s' rule", name, method.rule)
# Attach error handlers in the class
for name in [x for x in methods if x.startswith("error_")]:
method = getattr(self, name)
code = int(name.split("_", 2)[1])
self.app.error_handler_spec[None][code] = method
self.logger.debug("Adding handler '%s' for error code '%d'", name, code)
def run(self):
self.logger.debug("Waiting for clients")
try:
self.app.run(self.listener_address, self.listener_port)
except KeyboardInterrupt:
self.logger.warning("Canceled by the user")
self.stop()
def stop(self):
self.logger.debug("Stopping server")
def parse_node(self, response, node):
node.remove_namespaces()
cds_bibrec, ok, errs = create_bibrec(
node.xpath('.//record').extract()[0]
)
if not ok:
raise RuntimeError("Cannot parse record %s: %s", node, errs)
self.logger.info("Here's the record: %s" % cds_bibrec)
inspire_bibrec = CDS2Inspire(cds_bibrec).get_record()
marcxml_record = record_xml_output(inspire_bibrec)
record = create_record(marcxml_record)
app = Flask('hepcrawl')
app.config.update(
self.settings.getdict('MARC_TO_HEP_SETTINGS', {})
)
with app.app_context():
json_record = hep.do(record)
base_uri = self.settings['SCHEMA_BASE_URI']
json_record['$schema'] = base_uri + 'hep.json'
parsed_item = ParsedItem(
record=json_record,
record_format='hep',
)
return parsed_item
def register_handlers(app: Flask) -> Flask:
"""A function to register global request handlers.
To register a handler add them like the example
Example usage:
def fn(request: Request):
pass
app.before_request(fn)
Args:
app (Flask): Flask Application instance
Returns:
Flask: Flask Application instance
"""
identity_loaded.connect_via(app)(on_identity_loaded)
app.errorhandler(PermissionDenied)(permission_denied)
app.errorhandler(CSRFError)(invalid_csrf)
app.errorhandler(NoAuthorizationError)(invalid_csrf)
app.errorhandler(InvalidUsage)(invalid_error_handler)
app.errorhandler(Exception)(normalize_errors)
return app
def __init__(self, import_name, static_path=None, static_url_path=None,
static_folder='static', template_folder='templates',
instance_path=None, instance_relative_config=False, py_components_directories=[]):
Flask.__init__(self, import_name, static_path, static_url_path,
static_folder, template_folder,
instance_path, instance_relative_config)
self.__py_components_loader = BaseComponentLoader(self, py_components_directories)
def app_secured_from_configuration():
app = Flask(__name__)
app.config["OPA_SECURED"] = True
app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
app.opa = OPA(app, input_function=parse_input)
init_app(app)
return app
def test_register_handlers_registers_connection_handler_with_bindings_validation(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(bindings=ChannelBindings(
ws=WebSocketsChannelBindings(method="GET", )), )
},
)
server = new_mock_asynction_socket_io(spec)
flask_app = Flask(__name__)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(registered_handler)
with flask_app.test_client() as c:
with patch.object(server, "start_background_task"):
c.post() # Inject invalid POST request
actual_handler() # actual handler does not raise validation errors
with pytest.raises(BindingsValidationException):
handler_with_validation()
def create_app(spark_context, app):
global recommendationengine
recommendationengine = RecommendationEngine(spark_context, app)
app = Flask(__name__)
app.register_blueprint(main)
return app
def __init__(self,
dbUri='sqlite:///:memory:',
port=5000,
verbose=False,
serializer=jsonSerializerWithUri):
self.flaskApp = Flask(__name__,
static_url_path='',
static_folder=abspath('./static'))
print 'Using following sqlite database URI:', dbUri
self.flaskApp.config['SQLALCHEMY_DATABASE_URI'] = dbUri
self.flaskApp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
if verbose:
self.flaskApp.config['SQLALCHEMY_ECHO'] = True
@self.flaskApp.route('/')
def index():
return self.flaskApp.send_static_file('index.html')
self.port = port
self.serializer = serializer
self.namespaces = {}
def setUp(self):
modules.flags_manager.remove_all_flags()
self.app = Flask(__name__)
self.app.add_url_rule('/test', 'test', test_api, methods=['POST'])
init_flask('test_app', self.app, setup_kuber_config_loader=False)
flags.DEFINE_INTEGER_FLAG("test")
self.loader = KuberConfigLoader("test_service")
self.loader.load_config(
config_pb2.GlobalConfig(
flags=[{
"name": "test",
"type": "INTEGER",
"value": {
"base_value": {
"number_value": 1
}
}
}],
experiments={
2:
ExperimentDefinition(
id=2,
flag_values={
"test": FlagValue(base_value={"number_value": 2})
})
}))
self.server = Process(target=self.app.run, args=("127.0.0.1", 8008))
self.server.start()
sleep(1)
def app():
"""Import the test app"""
app = Flask(__name__)
app.config["OPA_SECURED"] = True
app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
app.opa = OPA(app, input_function=parse_input).secured()
init_app(app)
return app
def init_app(app: Flask):
from . import auth, user, order, shop, admin, merchant
app.register_blueprint(auth.app)
app.register_blueprint(user.app)
app.register_blueprint(order.app)
app.register_blueprint(shop.app)
app.register_blueprint(admin.app)
app.register_blueprint(merchant.app)
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object(hepdata_converter_ws)
from hepdata_converter_ws.api import api
app.register_blueprint(api)
return app
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object(hepdata_converter_ws)
from hepdata_converter_ws.api import api
app.register_blueprint(api)
return app
def init_app(app: Flask):
from src.api import models
db.init_app(app)
print(emojize('Base de dados conectada :outbox_tray:'))
with app.app_context():
db.create_all()
app.db = db
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def _create_json_record(xml_record):
object_record = create_record(etree.XML(xml_record))
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
{}))
with app.app_context():
dojson_record = hep.do(object_record)
return dojson_record
def build_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
app.secret_key = 'super secret key'
admin = Admin(app, name='Fuzz', template_mode='bootstrap3')
admin.add_view(ModelView(FuzzerIssue, db.session))
logging.basicConfig(level=logging.DEBUG)
return app
def setUp(self):
app = Flask(__name__)
app.testing = True
app.config["TESTING"] = True
setup_rest_api(app)
self.client = app.test_client
# Init db
DbSessionHolder(TestV1API.REST_TEST_DB).reset()
def setup(app: app.Flask):
'''
设置 中间件 蓝图 编码
'''
CorsMw.setupCors(app)
ErrorHandle.errorHandle(app)
GetRegionsBlue.registerBlueRegions(app)
app.config['JSON_AS_ASCII'] = False
app.config['UPLOAD_FOLDER'] = './tmp/'
def init_app():
app = Flask(__name__)
app.config.from_envvar("OIDCFED_RELYING_PARTY_CONFIG")
template_loader = jinja2.FileSystemLoader(["templates", "../templates"])
app.jinja_loader = template_loader
app.rp = init_oidc_fed_rp(app.config)
return app
def create_app(self):
from openbrokerapi.api import get_blueprint
app = Flask(__name__)
self.broker = Mock()
app.register_blueprint(
get_blueprint(self.broker, BrokerCredentials("", ""),
basic_config(level=logging.WARN)))
return app
def create_app(config_name: str = "default") -> Flask:
app = Flask(__name__)
init_config(app, config_name)
with app.app_context():
init_extensions(app)
init_blueprints(app)
init_commands(app)
return app
def main():
'''
This method registers all the end points of the application
'''
app = Flask(__name__)
app.secret_key = 'some_secret_key'
api = Api(app)
jwt = JWT(app, validate_user, get_user_based_on_identity)
api.add_resource(MyHanlder, '/api/hello')
return app
def init_app():
app = Flask(__name__)
template_loader = jinja2.FileSystemLoader(["templates", "../templates"])
app.jinja_loader = template_loader
app.config.from_envvar("OIDCFED_PROVIDER_CONFIG")
app.op = init_fed_op(app.config)
return app
def init_app():
app = Flask(__name__)
app.config.from_object(config)
app.template_folder = config.template_folder
handler = RotatingFileHandler(config.log_path,
maxBytes=10000,
backupCount=1)
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
register_blueprints(app)
return app
def create_app(self):
app = Flask(self.__class__.__name__)
app.config['TESTING'] = True
app.config['SECRET_KEY'] = 'VERYSECRET'
app.url_map.strict_slashes = False
self.register_blueprint(app)
self.app = app
return app
def test_opa_create_with_staticmethod_deny_access():
app = Flask(__name__)
opa_url = 'http://localhost:8181/v1/data/dm/allow'
app.opa = OPA.secure(app, input_function=parse_input, url=opa_url)
init_app(app)
responses.add(responses.POST, opa_url, json={'result': False}, status=200)
response = app.test_client().get('/')
assert 403 == response.status_code
def init_app(app: Flask):
# Register database functions with the Flask app
if not os.path.isdir(app.instance_path):
# Create the instance directory if it doesn't exist already
os.mkdir(app.instance_path)
db_path = os.path.dirname(app.config["DATABASE"])
if not os.path.isdir(db_path):
# Create the db directory if it doesn't exist already
os.mkdir(db_path)
app.teardown_appcontext(close_db)
app.cli.add_command(init_db_command)
def _create_json_record(xml_record):
object_record = create_record(etree.XML(xml_record))
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
{}))
with app.app_context():
dojson_record = hep.do(object_record)
base_uri = self.settings['SCHEMA_BASE_URI']
dojson_record['$schema'] = base_uri + 'hep.json'
return dojson_record
def create_app():
app = Flask(__name__)
bootstrap = Bootstrap(app)
app.config.from_object(Config)
# login manager inicializando la app
login_manager.init_app(app)
# Se registra el nuevo blueprint auth
app.register_blueprint(auth)
return app
def _parsed_items_from_marcxml(
self,
marcxml_records,
base_url="",
hostname="",
url_schema=None,
ftp_params=None,
url=""
):
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS', {}))
file_name = url.split('/')[-1]
with app.app_context():
parsed_items = []
for xml_record in marcxml_records:
try:
record = marcxml2record(xml_record)
parsed_item = ParsedItem(record=record, record_format='hep')
parsed_item.ftp_params = ftp_params
parsed_item.file_name = file_name
files_to_download = [
self._get_full_uri(
current_url=document['url'],
base_url=base_url,
schema=url_schema,
hostname=hostname,
)
for document in parsed_item.record.get('documents', [])
if self._has_to_be_downloaded(document['url'])
]
parsed_item.file_urls = files_to_download
self.logger.info('Got the following attached documents to download: %s'% files_to_download)
self.logger.info('Got item: %s' % parsed_item)
parsed_items.append(parsed_item)
except Exception as e:
tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
error_parsed_item = ParsedItem.from_exception(
record_format='hep',
exception=repr(e),
traceback=tb,
source_data=xml_record,
file_name=file_name
)
parsed_items.append(error_parsed_item)
return parsed_items
def _parsed_items_from_marcxml(
self,
marcxml_records,
base_url="",
hostname="",
url_schema=None,
ftp_params=None,
url=""
):
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS', {}))
file_name = url.split('/')[-1]
with app.app_context():
parsed_items = []
for xml_record in marcxml_records:
try:
record = marcxml2record(xml_record)
parsed_item = ParsedItem(record=record, record_format='hep')
parsed_item.ftp_params = ftp_params
parsed_item.file_name = file_name
files_to_download = [
self._get_full_uri(
current_url=document['url'],
base_url=base_url,
schema=url_schema,
hostname=hostname,
)
for document in parsed_item.record.get('documents', [])
if self._has_to_be_downloaded(document['url'])
]
parsed_item.file_urls = files_to_download
self.logger.info('Got the following attached documents to download: %s'% files_to_download)
self.logger.info('Got item: %s' % parsed_item)
parsed_items.append(parsed_item)
except Exception as e:
tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
error_parsed_item = ParsedItem.from_exception(
record_format='hep',
exception=repr(e),
traceback=tb,
source_data=xml_record,
file_name=file_name
)
parsed_items.append(error_parsed_item)
return parsed_items
def create_app():
application = Flask(__name__)
application.secret_key = gen_random_password()
Bootstrap(application)
application.register_blueprint(base_bp)
application.register_blueprint(files_bp)
application.register_blueprint(helpers_bp)
return application
def _get_crawl_result(xml_record):
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
{}))
with app.app_context():
item = ParsedItem(record={}, record_format='hep')
try:
item.record = marcxml2record(xml_record)
except Exception as e:
item.exception = repr(e)
item.traceback = traceback.format_tb(sys.exc_info()[2])
item.source_data = xml_record
return item
def setUp(self):
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = os.getenv("DATABASE_URL")
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy()
db.init_app(app)
app.app_context().push()
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['DEBUG'] = False
if not os.getenv("DATABASE_URL"):
raise RuntimeError("DATABASE_URL is not set")
self.app = app.test_client()
def _parsed_item_from_marcxml(marcxml_record, settings):
app = Flask('hepcrawl')
app.config.update(settings.getdict('MARC_TO_HEP_SETTINGS', {}))
with app.app_context():
try:
record = cds_marcxml2record(marcxml_record)
return ParsedItem(record=record, record_format='hep')
except Exception as e:
tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
return ParsedItem.from_exception(record_format='hep',
exception=repr(e),
traceback=tb,
source_data=marcxml_record)
def _parsed_items_from_marcxml(self, marcxml_records, base_url="", url=""):
self.logger.info('parsing record')
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS', {}))
file_name = url.split('/')[-1].split("?")[0]
with app.app_context():
parsed_items = []
for xml_record in marcxml_records:
try:
record = marcxml2record(xml_record)
parsed_item = ParsedItem(record=record,
record_format='hep')
parsed_item.file_name = file_name
new_documents = []
files_to_download = []
self.logger.info("Parsed document: %s", parsed_item.record)
self.logger.info("Record have documents: %s", "documents"
in parsed_item.record)
for document in parsed_item.record.get('documents', []):
if self._is_local_path(document['url']):
document['url'] = self._get_full_uri(
document['url'])
self.logger.info("Updating document %s", document)
else:
files_to_download.append(document['url'])
new_documents.append(document)
if new_documents:
parsed_item.record['documents'] = new_documents
parsed_item.file_urls = files_to_download
self.logger.info(
'Got the following attached documents to download: %s',
files_to_download)
self.logger.info('Got item: %s', parsed_item)
parsed_items.append(parsed_item)
except Exception as e:
tb = ''.join(traceback.format_tb(sys.exc_info()[2]))
error_parsed_item = ParsedItem.from_exception(
record_format='hep',
exception=repr(e),
traceback=tb,
source_data=xml_record,
file_name=file_name)
parsed_items.append(error_parsed_item)
return parsed_items
def create_app(config_name):
app = Flask(__name__)
print(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
# 初始化db
db.init_app(app)
login_manager.init_app(app)
# 初始化日志配置
common = LogCommon()
app = common.init_log(app, 'log')
# 附加路由和自定义的错误页面
from app.pyweb.main import main
app.register_blueprint(main)
# 定义认证路由
from app.pyweb.auth import auth
app.register_blueprint(auth, url_prefix='/auth')
# 定义Captcha路由
from app.pyweb.captcha_chinese import captcha
app.register_blueprint(captcha, url_prefix='/captcha')
return app
def stuff_client(app: Flask):
client = app.test_client()
user = User("stuff", "*****@*****.**", stuff=True)
user.set_password("stuffpsw")
with app.app_context():
db.session.add(user)
db.session.commit()
res = client.post("/auth/token/login",
json={
"username": "******",
"password": "******",
})
assert res.is_json
token = res.get_json().get("token")
client.environ_base["HTTP_AUTHORIZATION"] = "Bearer {}".format(token)
return client
def app_factory(config):
'''This factory creates a Flask application instance based on the settings
in the provided configuration object.'''
# Create the Flask app, register the blueprint and initialize the
# flask-mail service.
# Blueprints must be used to implement factories (I believe) because
# they allow the factory to register the application's routes
# before they must be implemented.
app = Flask(__name__)
app.config.from_object(config)
from app.views import web
app.register_blueprint(web)
mail.init_app(app)
# Create the (only) mongodb instance for use by all running applications.
# Different apps may use different Mongo databases.
# The production server already has its data, so don't always
# call db_reset().
mongo = PyMongo(app)
if config.DATA:
with app.app_context():
db_reset(mongo, config.DATA)
# Store the Mongo database object in the Flask globals so that it can
# be accessed when needed.
@app.before_request
def before_request():
g.mongo = mongo
# This Jinja2 template must be defined here, on the app, rather than
# in views.py on the blueprint.
@app.template_filter('start_token')
def start_token(name):
'''This routine returns the substring of the given name up to but not
including the first slash. If there is no slash, it returns the
full name. It is used in the templates to find either the page
name or category.'''
if (name.find('/') == -1):
return name
else:
return name[:name.find('/')]
return app
def setUp(self):
self.app = Flask(__name__)
self.app.register_blueprint(emailactivation.views.app)
self.app.config['SECRET_KEY'] = 'SECRET'
self.mail = Mail(self.app)
@self.app.route('/index')
def index():
return 'index'
class TestNegotiate(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.secret_key = 'test'
def _mock_headers(self, headers=None, **kwargs):
if headers is None:
headers = {}
ctx = self.app.test_request_context('', headers=headers, **kwargs)
ctx.push()
class EmailActivationTest(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.register_blueprint(emailactivation.views.app)
self.app.config['SECRET_KEY'] = 'SECRET'
self.mail = Mail(self.app)
@self.app.route('/index')
def index():
return 'index'
def testSendEmail(self):
callback = my_callback
data = {'mail':'*****@*****.**'}
email = {'subject':'subject',
'sender':'*****@*****.**'}
with patch('test_activation.my_callback') as c:
with self.app.test_request_context():
c.return_value = url_for('index')
signature = signature_serialize(callback, data)
with self.mail.record_messages() as outbox:
send_activation_email(self.mail,
'*****@*****.**',
callback=callback,
data=data,
email_context=email,
template_context={},
body_template='test.html')
self.assertEquals(1, len(outbox), 'Email was sent')
self.assertIn(url_for('emailactivation.activation',
signature=signature, _external=True),
outbox[0].body)
with self.app.test_client() as client:
response = client.get(url_for('emailactivation.activation',
signature=signature,))
self.assertEquals(302, response.status_code)
self.assertEquals(url_for('index', _external=True),
response.location)
def create_app(config: dict = {}, mail_client=None):
app = Flask(__name__, static_folder='static')
if config:
app.config.update(config)
else:
app.config.from_envvar('ALSERVICE_CONFIG')
MakoTemplates(app)
app._mako_lookup = TemplateLookup(directories=[pkg_resources.resource_filename('alservice.service', 'templates')],
input_encoding='utf-8', output_encoding='utf-8',
imports=['from flask_babel import gettext as _'])
app.al = init_account_linking(app, mail_client)
babel = Babel(app)
babel.localeselector(get_locale)
app.config['BABEL_TRANSLATION_DIRECTORIES'] = pkg_resources.resource_filename('alservice.service',
'data/i18n/locales')
from .views import account_linking_views
app.register_blueprint(account_linking_views)
setup_logging(app.config.get('LOGGING_LEVEL', 'INFO'))
logger = logging.getLogger(__name__)
logger.info('Running ALservice version %s', pkg_resources.get_distribution('ALservice').version)
return app
def make_app(import_name=__name__, config="homebank.settings.Configuration", debug=False):
app = Flask(import_name)
app.config.from_object(config)
app.config.from_envvar("FLASK_SETTINGS", silent=True)
app.debug = debug
app.jinja_env.filters["currency"] = lambda x: "{:,.2f} %s".format(x).replace(",", " ").replace(".", ",") % (
app.config.get("CURRENCY", "")
)
if app.debug:
import_string("flask.ext.debugtoolbar:DebugToolbarExtension")(app)
@app.errorhandler(404)
def not_found(ex):
return render_template("404.html"), 404
for blueprint in ["__init__", "accounts", "transactions"]:
app.register_blueprint(import_string("homebank.blueprints.%s:root" % blueprint))
login_manager = LoginManager(app=app)
login_manager.login_view = "index.login"
login_manager.session_protection = "strong"
@login_manager.user_loader
def load_user(uid):
if uid != app.config["PINCODE"]:
return None
return User()
if not app.debug:
handler = StreamHandler()
if "ERROR_LOG" in app.config:
handler = WatchedFileHandler(app.config["ERROR_LOG"])
handler.setLevel(WARNING)
handler.setFormatter(Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
app.logger.addHandler(handler)
return app
def setup_server(self):
super(BaseHTTPService, self).setup_server()
# Create an Flask application for this service using the service name
self.app = Flask(self.application_name or self.__class__.__name__, template_folder=self.template_folder or None)
methods = dir(self)
# Attach each route in the class
for name in [x for x in methods if x.startswith("route_")]:
method = getattr(self, name)
self.app.add_url_rule(method.rule, name, method)
self.logger.debug("Adding handler '%s' for '%s' rule", name, method.rule)
# Attach error handlers in the class
for name in [x for x in methods if x.startswith("error_")]:
method = getattr(self, name)
code = int(name.split("_", 2)[1])
self.app.error_handler_spec[None][code] = method
self.logger.debug("Adding handler '%s' for error code '%d'", name, code)
def setUp(self):
self.app = Flask(__name__)
self.test_client = self.app.test_client()
self.init_logging()
self.init_validator_context()
self.config = TEST_CONFIG
self.auth_cookie = None
load_filters(self.app.jinja_env, self.config)
self.app_context = self.app.app_context()
self.app_context.__enter__()
set_template_loader(self.app.jinja_env)
init_configuration(self.app, self.config)
init_blueprints(self.app)
init_services(self.app)
init_login_system(self.app)
init_db(self.app)
init_plugins()
self.mailer = celery.conf['MAILER']
self.mailer.mails = []
self.sms_sender = celery.conf['SMS_SENDER']
self.sms_sender.sms = []
self.user = None
self.user_profile = None
UserManager.init(self.config, self.app.logger)
sql_db.init_app(self.app)
sql_db.create_all()
for table in reversed(sql_db.metadata.sorted_tables):
sql_db.engine.execute(table.delete())
@self.app.errorhandler(413)
def catcher(error):
data_json = json.dumps({"error": {"code": errors.FileToLarge.ERROR_CODE, "message": errors.FileToLarge.ERROR_MESSAGE}})
result = Response(data_json, mimetype='application/json', status=400)
result.headers.add('Access-Control-Allow-Credentials', "true")
result.headers.add('Access-Control-Allow-Origin', "http://%s" % self.config['site_domain'])
return result
def setUp(self):
self.app = Flask(__name__)
self.client = self.app.test_client()
self.db = MongoEngine(self.app)
with self.app.app_context():
self.db.connection.drop_database("test")
# self.db.connection
class TestCol(db.Document):
value = db.StringField()
def __unicode__(self):
return "TestCol(value={})".format(self.value)
TestCol.objects.delete()
TestCol.objects.create(value="1")
TestCol.objects.create(value="2")
self.TestCol = TestCol
def __new__(cls, *args, **kwargs):
if cls._instance is None:
app = Flask(__name__)
app.register_blueprint(PeopleBluePrintFactory.create())
flask_injector = FlaskInjector(
app=app,
modules=[DatabaseModule(), ],
)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/production.db'
db.init_app(app)
with app.app_context():
db.create_all()
cls._instance = flask_injector
return cls._instance
from flask.app import Flask
from flask.templating import render_template
import urllib2
from flask.globals import request
from bs4 import BeautifulSoup
import sqlite3 as lite
import HTMLParser
DATABASE = 'nc4h.db'
nc4hers = ["Sarah Kotzian","Amy Chilcote","David Herpy Larry Hancock","Michael Yoder","Salim Oden","Shannon McCollum","Mitzi Downing"]
nc4h = Flask(__name__)
nc4h.secret_key = 'nc4h'
@nc4h.route('/')
def home():
return render_template('home.html')
@nc4h.route('/add')
def add_submission():
return render_template('index.html')
@nc4h.route('/getname/',methods=["GET"])
def getname():
url = request.args.get('transferurl')
usock = urllib2.urlopen(url)
filer = usock.read();
parsed_html = BeautifulSoup(filer, "html5lib")
my_out = str(parsed_html.find('title')).replace('<title>','').replace('</title>','').replace('|','').replace('NC 4-H Youth Development','')
h = HTMLParser.HTMLParser()
s = h.unescape(my_out)
from socketio import socketio_manage
from socketio.mixins import BroadcastMixin
from werkzeug.exceptions import BadRequest
from gevent import monkey
monkey.patch_all()
from socketio.namespace import BaseNamespace
from socketio.server import SocketIOServer
from werkzeug.wsgi import SharedDataMiddleware
from werkzeug.serving import run_with_reloader
from flask.app import Flask
from TwitterAPI import TwitterAPI
app = Flask(__name__)
app.config['DEBUG'] = True
TwitterApi = TwitterAPI(
'RfJOrhv4ElNAGb4dQnJZ3A',
'dwEu677epT6xzwWrVu2UwVwNH9FPr6LwDUOippVb4',
'39249210-Fl4xReKp6Uh0cIUV4rHS3FCh9J8uj9y9DVHwRQSHP',
'v0XwZ2ma1xdpA35as6a02YR9ihONT55BtjWMLc0Npsr6o'
)
def send_tweets(socket, hashtag_value):
tweets = TwitterApi.request('statuses/filter', {'track': hashtag_value})
for tweet in tweets.get_iterator():
socket.emit('tweet', tweet)
gevent.sleep()
# -*- coding: utf-8 -*-
'''
MiniTwit
~~~~~~~~
A microblogging applicatoin written with Flask and sqlite3.
'''
# configuration
DATABASE = '../../minitwit.db'
PER_PAGE = 30
DEBUG = True
SECRET_KEY = 'development key'
# create our little applicatoin
app = Flask(__name__)
app.config.from_object(__name__) # read configuration from this file
app.config.from_envvar('MINITWIT_SETTING', silent=True)
def connect_db():
"""
:return: a new connection to the database
"""
return sqlite3.connect(app.config['DATABASE'])
def init_db():
"""
Creates the database tables.
"""
with closing(connect_db()) as db:
with app.open_resource('schema.sql') as f:
def run():
""" daemon run function.
This function should be called to start the system.
"""
instance_path = ini_config.get("Flask", "INSTANCE_PATH")
# app: Flask application object
logging.debug("initializing the Flask app")
global globalFlaskApp
globalFlaskApp = Flask(__name__,
instance_path=instance_path,
instance_relative_config=True)
is_debug = ini_config.getboolean("Flask", "DEBUG")
is_testing = ini_config.getboolean("Flask", "TESTING")
is_json_sort_keys = ini_config.getboolean("Flask", "JSON_SORT_KEYS")
max_content_length = ini_config.getint("Flask", "MAX_CONTENT_LENGTH")
globalFlaskApp.config.update(DEBUG=is_debug,
TESTING=is_testing,
JSON_SORT_KEYS=is_json_sort_keys,
MAX_CONTENT_LENGTH=max_content_length)
with globalFlaskApp.app_context():
logging.info("Starting application ...")
from rgapps.utils.utility import get_log_file_handles
logger_fds = get_log_file_handles(logging.getLogger())
logging.debug("Logger file handles fileno [{0}]"
.format(logger_fds))
system = platform.system()
if system == "Linux":
logging.info("Server running on Linux.")
pid_file = ini_config.get("Sensor", "SENSOR_PID_FILE")
working_dir = ini_config.get("Logging", "WORKING_DIR")
logging.debug("Instantiating daemon with pid_file [{0}] "
"and working_dir [{1}]"
.format(pid_file, working_dir))
import daemon.pidfile
daemon_context = daemon.DaemonContext(
working_directory=working_dir,
umask=0o002,
pidfile=daemon.pidfile.PIDLockFile(pid_file))
logging.debug("Setting up daemon signal map")
daemon_context.signal_map = { signal.SIGTERM: program_cleanup }
logging.debug("daemon signal map has been setup")
if (logger_fds):
logging.debug("setting files_preserve for the log file "
"descriptor [{0}]"
.format(logger_fds))
daemon_context.files_preserve = logger_fds
logging.debug("Starting daemon by opening its context.")
daemon_context.open()
logging.info("Calling read_store_readings....")
read_store_readings()
logging.debug("Closing the daemon context.")
daemon_context.close()
else:
logging.info("Server running on Windows system ...")
read_store_readings()
return
from flask.app import Flask
from flask.globals import request
from flask.json import jsonify
from flask.templating import render_template
import json
from app_controller import get_app_controller
"""
The REST APIs are defined in this file.
"""
app = Flask(__name__)
app_controller = get_app_controller()
"""
Called to display movie details on webpage. It returns a random movie from list of movies.
"""
@app.route('/getNextMovie', methods=['GET'])
def get_next_movie():
session_id = request.args.get('sessionId').encode('utf-8')
return jsonify(app_controller.get_next_movie(session_id))
"""
Called to save a rating submitted by user in the db.
"""
@app.route('/saveMovieRating', methods=['POST'])
def save_movie_rating():
movie_id = request.form['movieId'].encode('utf-8')
rating = request.form['rating'].encode('utf-8')
class BaseTestCase(TestCase):
def setUp(self):
self.app = Flask(__name__)
self.test_client = self.app.test_client()
self.init_logging()
self.init_validator_context()
self.config = TEST_CONFIG
self.auth_cookie = None
load_filters(self.app.jinja_env, self.config)
self.app_context = self.app.app_context()
self.app_context.__enter__()
set_template_loader(self.app.jinja_env)
init_configuration(self.app, self.config)
init_blueprints(self.app)
init_services(self.app)
init_login_system(self.app)
init_db(self.app)
init_plugins()
self.mailer = celery.conf['MAILER']
self.mailer.mails = []
self.sms_sender = celery.conf['SMS_SENDER']
self.sms_sender.sms = []
self.user = None
self.user_profile = None
UserManager.init(self.config, self.app.logger)
sql_db.init_app(self.app)
sql_db.create_all()
for table in reversed(sql_db.metadata.sorted_tables):
sql_db.engine.execute(table.delete())
@self.app.errorhandler(413)
def catcher(error):
data_json = json.dumps({"error": {"code": errors.FileToLarge.ERROR_CODE, "message": errors.FileToLarge.ERROR_MESSAGE}})
result = Response(data_json, mimetype='application/json', status=400)
result.headers.add('Access-Control-Allow-Credentials', "true")
result.headers.add('Access-Control-Allow-Origin', "http://%s" % self.config['site_domain'])
return result
def tearDown(self):
sql_db.session.close()
#sql_db.drop_all()
for table in reversed(sql_db.metadata.sorted_tables):
sql_db.engine.execute(table.delete())
# noinspection PyUnresolvedReferences
self.app.model_cache_context.clear()
self.app_context.__exit__(None, None, None)
def get_test_resource_name(self, name):
return os.path.join(CURRENT_DIR, 'test_data', name)
def init_logging(self):
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
consoleHandler.setLevel(logging.DEBUG)
self.app.logger.addHandler(consoleHandler)
self.app.logger.setLevel(logging.DEBUG)
def init_validator_context(self):
self.app.validator_context = ValidatorContext()
self.app.rendering_context = RenderingContext()
self.app.model_cache_context = ModelCacheContext()
def setUp(self):
self.app = Flask(__name__)
self.app.secret_key = 'test'
import logging
from flask.app import Flask
from apps.config.apps_config import db_session, log_file
app = Flask(__name__)
from apps.billing.views import mod as billingModule
from apps.login.views import mod as loginModule
app.register_blueprint(billingModule)
app.register_blueprint(loginModule)
@app.teardown_appcontext
def shutdown_session(exception=None):
log.info("----------------- IN Shutdown session --------------")
db_session.remove()
log.info("----------------- AFter RemoveShutdown session --------------")
logging.basicConfig(filename=log_file, level=logging.DEBUG)
log = logging.getLogger()
import argparse
import urllib
import urllib2
import re
from flask.app import Flask
from flask import request, make_response
app = Flask(__name__)
close_head_regexp = re.compile("</head>", re.IGNORECASE)
href_regexp = re.compile("href\s?=\s?[\"']http://([\w\.]+)(/?.*?)[\"']", re.IGNORECASE | re.MULTILINE)
src_regexp = re.compile("src\s?=\s?[\"'][htps:]*//([\w\.]+)(/?.*?)[\"']", re.IGNORECASE | re.MULTILINE)
PROXY_REQUEST_HEADER_PREFIXES = [
"x-",
"cookie",
"user-agent",
"cache-control",
]
PROXY_RESPONSE_HEADER_PREFIXES = [
"x-",
"content-type",
"content-disposition",
"date",
"expires",
"pragma",
"p3p",
"set-cookie",
from flask.app import Flask
from flask.ext.admin.base import MenuLink
import settings
from todo_app.admin_views import AdminIndex
from werkzeug.debug import DebuggedApplication
from flask_admin import Admin
from google.appengine.api import users
flask_app = Flask(__name__)
flask_app.config.from_object(settings)
admin = Admin(flask_app, name='TODO', index_view=AdminIndex(url='/admin', name='Home'), )
admin.add_link(MenuLink(name='Logout',url = users.create_logout_url('/')))
if flask_app.config['DEBUG']:
flask_app.debug = True
app = DebuggedApplication(flask_app, evalex=True)
app = flask_app
from todo_app import admin_views
from todo_app import views
from chisubmit.common import ChisubmitException
from chisubmit.common.utils import gen_api_key
from chisubmit.backend.webapp.api.json_encoder import CustomJSONEncoder
from chisubmit.backend.webapp.api.blueprints import api_endpoint
from flask.app import Flask
from flask.ext.sqlalchemy import SQLAlchemy
import wtforms_json
from chisubmit.backend.webapp.auth.testing import TestingAuth
from chisubmit.backend.webapp.auth import set_auth
from chisubmit.backend.webapp.auth.ldap import LDAPAuth
wtforms_json.init()
app = Flask(__name__)
app.json_encoder = CustomJSONEncoder
db = SQLAlchemy(app)
import chisubmit.backend.webapp.api.views
app.register_blueprint(api_endpoint, url_prefix='/api/v0')
class ChisubmitAPIServer(object):
def __init__(self, debug):
self.app = app
self.db = db
self.debug = debug
