from backend import create_app app = create_app("test")
def setUp(self): self.app = create_app() self.ctx = self.app.app_context() self.ctx.push()
def app(): alterspace_app = create_app() alterspace_app.register_blueprint(backend_app) return alterspace_app
from backend import create_app app = create_app() if __name__ == '__main__': app.run(host='127.0.0.1', port=8080, debug=True)
# -*- coding:utf-8 -*- from backend import create_app, socketio from backend.config.LocalConfig import local from flask import request, jsonify, render_template from backend.models import * from backend.common import * from flask_socketio import emit app = create_app(local) if __name__ == "__main__": app.run(host="0.0.0.0", port=10004, debug=True) # socketio.run(app, host="0.0.0.0", port= 10004)
# -*- coding: utf-8 -*- from backend import create_app if __name__ == '__main__': app = create_app('config.ProductionConfig') use_debugger = app.debug and not (app.config.get('DEBUG_WITH_APTANA')) app.run(use_debugger=use_debugger, debug=app.debug, use_reloader=use_debugger, host="127.0.0.1")
from backend import create_app from flask_migrate import Manager, MigrateCommand from backend import db from backend.members.models import Member, ListMembership, List, MailchimpTag manager = Manager(create_app()) manager.add_command('db', MigrateCommand) @manager.command def seed(): m = Member(first_name='Erin', last_name='Stuelke') db.session.add(m) db.session.commit() if __name__ == "__main__": manager.run()
import os, sys sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) from flask.ext.script import Manager, Shell from backend import create_app, db app = create_app('dev') manager = Manager(app) @manager.command def dedup(): from backend.models import SearchResult, Search, Image search_results = SearchResult.query.filter( SearchResult.image_scraped_state == 'SUCCESS').limit(100).offset( 10000).all() for search_result in search_results: duplicate_pool = (SearchResult.query.join(Image).join(Search).filter( Search.survey == search_result.search.survey).filter( Image.image_hash == search_result.image.image_hash).all()) print(search_result.id_, len(duplicate_pool)) @manager.command def background_work(): from backend.background_work import do_work app = create_app('prod') do_work()
def background_work(): from backend.background_work import do_work app = create_app('prod') do_work()
import os from backend import create_app # from models import db from flask_script import Manager, Shell from instance.config import ProConfig, DevConfig from backend.database import db ENV = {"development": DevConfig, "production": ProConfig} app = create_app(ENV.get(os.getenv("FLASK_ENV"), DevConfig)) manage = Manager(app) if __name__ == "__main__": manage.run()
# -*- coding: utf-8 -*- from __future__ import (absolute_import, unicode_literals, print_function, division) import os from flask.ext.script import Manager, Server from backend import create_app from flask import url_for from config import Config, DevelopmentConfig, TestingConfig, ProductionConfig app = create_app(config=TestingConfig) manager = Manager(app) manager.add_command("runserver", Server( use_debugger = app.config.get('DEBUG', True), use_reloader = app.config.get('DEBUG', True), host = app.config.get('HOST', '0.0.0.0')) ) @manager.command def runtests(): print("Testing solarcalculator package.") from tests import solarcalculator_test solarcalculator_test() print("Test finished.") print() print("Testing solarstats class.") from tests import solarstats_test solarstats_test() print("Test finished.")
from backend import create_app from dotenv import load_dotenv import os from backend import api import logging logger = logging.getLogger(__name__) dotenv_path = os.path.join(os.path.dirname(__file__), '.env') if os.path.exists(dotenv_path): load_dotenv(dotenv_path) application = create_app(os.getenv('FLASK_CONFIG') or 'default') api.init_app(application) application.run()
"""A Python Flask REST API BoilerPlate (CRUD) Style""" import argparse import os from dotenv import load_dotenv from backend import create_app load_dotenv() APP = create_app() if __name__ == '__main__': PARSER = argparse.ArgumentParser( description="Casting Agency - FSND Capstone app") PARSER.add_argument('--debug', action='store_true', help="""Use flask debug/dev mode with file change reloading""") ARGS = PARSER.parse_args() PORT = int(os.environ.get('PORT', 5000)) if ARGS.debug: print("Running in debug mode") APP.run(host='0.0.0.0', port=PORT, debug=True) else: APP.run(host='0.0.0.0', port=PORT, debug=False)
# Check that required environmental variables are set for key in [ "TM_APP_BASE_URL", "POSTGRES_DB", "POSTGRES_USER", "POSTGRES_PASSWORD", "TM_SECRET", "TM_CONSUMER_KEY", "TM_CONSUMER_SECRET", "TM_DEFAULT_CHANGESET_COMMENT", ]: if not os.getenv(key): warnings.warn("%s environmental variable not set." % (key, )) # Initialise the flask app object application = create_app() # Initialize homepage counters try: initialise_counters(application) except Exception: warnings.warn("Homepage counters not initialized.") # Add management commands manager = Manager(application) # Enable db migrations to be run via the command line manager.add_command("db", MigrateCommand) # Setup a background cron job cron = Scheduler(daemon=True)
def setUp(self): app = create_app() app.config['TESTING'] = True self.app = app.test_client() app.app_context().push() users.db.create_all()
from backend import create_app from backend.models import db, User, Shop, CustomerDatapoint from datetime import datetime, timedelta import random from getpass import getpass with create_app().app_context(): print('Creating user') name = input('Name: ') email = input('Email: ') password = None confirmed = False while not confirmed: password = getpass('Password: '******'Confirm Password: '******'Passwords do not match') u = User(name=name, email=email) u.set_password(password) db.session.add(u) shop = Shop( name='My Awesome Supermarket', capacity=50, contact_info='Richard Feynman\[email protected]\n+49123456789', address='1234 Fermi Street\n56789 Los Alamos\nUSA', )
import backend import config app = backend.create_app(config) # This is only used when running locally. When running live, gunicorn runs # the application. if __name__ == '__main__': app.run(host='127.0.0.1', port=8080, debug=True)
#!/usr/bin/env python # -*- coding:utf-8 -*- import os import sys reload(sys) # Reload does the trick! sys.setdefaultencoding('UTF8') from backend import create_app app = create_app(os.getenv('FLASK_CONFIG') or 'development') if __name__ == "__main__": from backend import manager manager.run()
import json import pytest from backend import create_app app = create_app("testing") @pytest.fixture def client(request): test_client = app.test_client() return test_client def post_json(client, url, json_dict): return client.post(url, data=json.dumps(json_dict), content_type="application/json") def decode_response(response): return json.loads(response.data.decode("utf8")) def test_predict_endpoint(client): response = post_json(client, "/api/predict", {'points': [75, 76, 77]}) assert response.status_code == 200 assert decode_response(response) == { "response": [284.28057575230645, 287.9241248492282, 291.5676739461499] }
import os from backend import create_app, db from backend.models import User, ActivityData from flask_migrate import Migrate app = create_app(os.getenv('FLASK_CONFIG') or 'default') migrate = Migrate(app, db) @app.shell_context_processor def make_shell_context(): return dict(db=db, User=User) @app.cli.command() def test(): '''Run the unit tests''' import unittest tests = unittest.TestLoader().discover('tests') unittest.TextTestRunner(verbosity=2).run(tests)
import os from backend import create_app frontend_folder_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'frontend') app = create_app(static_folder=frontend_folder_path, static_url_path='') if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) app.run(host='0.0.0.0', port=port) #app.run(debug=True)
import os from backend import create_app application = create_app(config_name=os.environ.get('APP_MODE'))
import backend app = backend.create_app()
import os from flask_script import Manager, Server from flask_script.commands import ShowUrls, Clean from backend import create_app from backend.models import db, User # default to dev config because no one should use this in # production anyway env = os.environ.get('APP_ENV', 'prod') app = create_app('backend.settings.%sConfig' % env.capitalize()) manager = Manager(app) manager.add_command("server", Server()) manager.add_command("show-urls", ShowUrls()) manager.add_command("clean", Clean()) @manager.shell def make_shell_context(): """ Creates a python REPL with several default imports in the context of the backend """ return dict(app=app, db=db, User=User) @manager.command def createdb(): """ Creates a database with all of the tables defined in your SQLAlchemy models
def flask_app(domain_ip): app = create_app(flask_env="test") app.config["WILLSTORES_WS"] = "http://" + domain_ip + ":8001" app.config["WILLORDERS_WS"] = "http://" + domain_ip + ":8002" app.test_client_class = FlaskLoginClient return app
def login_disabled_app(flask_app): test_app = create_app(flask_env="test") test_app.config = flask_app.config test_app.config["LOGIN_DISABLED"] = True yield test_app
def send_message_after_chat(chat_from: int, chat: str, project_id: int): """ Send alert to user if they were @'d in a chat message """ # Because message-all run on background thread it needs it's own app context app = create_app() with app.app_context(): usernames = MessageService._parse_message_for_username(chat, project_id) if len(usernames) != 0: link = MessageService.get_project_link( project_id, include_chat_section=True ) messages = [] for username in usernames: current_app.logger.debug(f"Searching for {username}") try: user = UserService.get_user_by_username(username) except NotFound: current_app.logger.error(f"Username {username} not found") continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.MENTION_NOTIFICATION.value message.project_id = project_id message.from_user_id = chat_from message.to_user_id = user.id message.subject = f"You were mentioned in {link} chat" message.message = chat messages.append(dict(message=message, user=user)) MessageService._push_messages(messages) query = """ select user_id from project_favorites where project_id = :project_id""" favorited_users_results = db.engine.execute( text(query), project_id=project_id ) favorited_users = [r[0] for r in favorited_users_results] # Notify all contributors except the user that created the comment. contributed_users_results = ( TaskHistory.query.with_entities(TaskHistory.user_id.distinct()) .filter(TaskHistory.project_id == project_id) .filter(TaskHistory.user_id != chat_from) .filter(TaskHistory.action == TaskAction.STATE_CHANGE.name) .all() ) contributed_users = [r[0] for r in contributed_users_results] users_to_notify = list(set(contributed_users + favorited_users)) if len(users_to_notify) != 0: from_user = User.query.get(chat_from) from_user_link = MessageService.get_user_link(from_user.username) project_link = MessageService.get_project_link( project_id, include_chat_section=True ) messages = [] for user_id in users_to_notify: try: user = UserService.get_user_dto_by_id(user_id) except NotFound: continue # If we can't find the user, keep going no need to fail message = Message() message.message_type = MessageType.PROJECT_CHAT_NOTIFICATION.value message.project_id = project_id message.from_user_id = chat_from message.to_user_id = user.id message.subject = ( f"{from_user_link} left a comment in {project_link}" ) message.message = chat messages.append(dict(message=message, user=user)) # it's important to keep that line inside the if to avoid duplicated emails MessageService._push_messages(messages)
# -*- coding: utf-8 -*- # Author: hpf # Date: 2020/4/2 下午2:52 # File: wsgi.py # IDE: PyCharm from backend import create_app # from backend.extensions import celery_ext app = create_app('production')