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')
