def test_run_withhout_appium(self, mocked_avd, mocked_subprocess): with mock.patch('src.app.appium_run') as mocked_appium: os.environ['APPIUM'] = str(False) app.run() self.assertTrue(mocked_avd.called) self.assertTrue(mocked_subprocess.called) self.assertFalse(mocked_appium.called)
def test_run_with_appium(self, mocked_avd, mocked_open, mocked_subprocess): with mock.patch('src.app.appium_run') as mocked_appium: os.environ['APPIUM'] = str(True) app.run() self.assertTrue(mocked_avd.called) self.assertTrue(mocked_subprocess.called) self.assertTrue(mocked_appium.called)
def test_run_without_appium(self, mocked_avd, mocked_subprocess): with mock.patch('src.app.appium_run') as mocked_appium: os.environ['AVD'] = str(False) os.environ['APPIUM'] = str(False) app.run() self.assertFalse(mocked_avd.called) self.assertFalse(mocked_subprocess.called) self.assertFalse(mocked_appium.called)
def test_run_without_avd(self, mocked_appium): with mock.patch('src.app.prepare_avd') as mocked_avd: with mock.patch('subprocess.Popen') as mocked_subprocess: os.environ['AVD'] = str(False) os.environ['APPIUM'] = str(False) app.run() self.assertFalse(mocked_avd.called) self.assertFalse(mocked_subprocess.called) self.assertFalse(mocked_appium.called)
def run(host, port, debug): """Runs a development web server.""" if debug: from src import app app.run(host=host, port=port, debug=debug) else: bind = '%s:%s' % (host, port) subprocess.call( ['gunicorn', 'src:app', '--bind', bind, '--log-file=-'])
def test_run_with_appium_and_relaxed_security(self, mocked_avd, mocked_open, mocked_subprocess): with mock.patch('src.app.appium_run') as mocked_appium: os.environ['APPIUM'] = str(True) os.environ['RELAXED_SECURITY'] = str(True) app.run() self.assertTrue(mocked_avd.called) self.assertTrue(mocked_subprocess.called) self.assertTrue(mocked_appium.called)
def run(self) -> bool: self.register_views() app.jinja_env.globals['url_for_other_page'] = self.url_for_other_page app.run(host=self.host, port=self.port, debug=self.debug, use_reloader=self.use_reloader, threaded=self.threaded) return True
class check: count = 0 if count == 0: print(count) count += 1 global APP_ROOT, app app = Flask(__name__) APP_ROOT = os.path.dirname(os.path.abspath(__file__)) @staticmethod def get_files(): from os import listdir from os.path import isfile, join mypath = '/home/momo/PycharmProjects/Malware_Analysis/src/images/' onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))] for f in onlyfiles: print(f) @staticmethod @app.route("/") def index(): return render_template("upload.html") @staticmethod @app.route("/upload", methods=['POST']) def upload(): target = os.path.join(APP_ROOT, 'images/') # print(target) if not os.path.isdir(target): os.mkdir(target) for file in request.files.getlist("file"): # print(file) filename = file.filename destinaton = "/".join([target, filename]) # print(destinaton) file.save(destinaton) from src import app app.check.get_files() return 'File uploaded!' #return render_template("complete.html") if __name__ == '__main__': app.run(port=4555)
from src import app if __name__ == '__main__': app.run(host='0.0.0.0', debug=True, port=5000, threaded=False)
# from flask import Flask # from flask import render_template, request, redirect, url_for from src import app if __name__ == "__main__": app.run('localhost', '8080')
from src.utils.load_config import config from src import app if __name__ == "__main__": app.run(debug=config.DEBUG, host=config.HOST, port=config.PORT)
from src import app if __name__ == '__main__': app.run(port=5000, host="0.0.0.0")
from flask_script import Manager, Server from src import app manager = Manager(app) manager.add_command("runserver", Server('0.0.0.0', port=3001)) Application = app if __name__ == '__main__': # manager.run() app.run(debug=True, host='0.0.0.0', port=3001)
import os from src import app if __name__ == "__main__": HOST = os.environ.get("SERVER_HOST", "localhost") try: PORT = int(os.environ.get("SERVER_PORT", "5555")) except ValueError: PORT = 1234 app.secret_key = "1cd6f35db029d4b8fc98fc05c9efd06a2e2cd1ffc3774d3f035ebd8d" app.run(HOST, PORT, debug=True)
name = "Sot" return render_template('profile.html', name = name) def allowed_filename(filename): return '.' in filename and filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS @app.route('/edit', methods=['GET', 'POST']) def upload_file(): if request.method == 'POST': file = request.files['file'] if file and allowed_filename(file.filename): filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) return redirect(url_for('uploaded_file', filename=filename)) return render_template('edit.html') @app.route('/uploads/<filename>') def uploaded_file(filename): return send_from_directory(app.config['UPLOAD_FOLDER'], filename) with app.test_request_context(): print(url_for('index')) if __name__ == "__main__": app.debug = True app.run()
from src import app if __name__ == "__main__": # app.run() app.run(host="0.0.0.0", port=80)
#!/usr/bin/python from src import app app.debug = True app.run();
from src import app __author__ = "Nupur Baghel" app.run(debug=app.config['DEBUG'],port=4995)
#! /usr/bin/env python import os, sys, platform minor = "py2{0}".format(sys.version_info[1]) if os.name == "posix": if platform.system() == "Darwin": sys.path.append(os.path.join("./lib/osx", minor)) else: if platform.architecture()[0] == "64bit": sys.path.append(os.path.join("./lib/lin64", minor)) else: sys.path.append(os.path.join("./lib/lin32", minor)) else: sys.path.append(os.path.join("./lib/win32", minor)) from src import app, scenes editor = scenes.get("editor")() app = app.Application() app.run(editor)
# !/usr/bin/env python # -*- coding: utf-8 -*- from src import app from src.controllers import controllers from src.services import services app.register_blueprint(controllers) app.register_blueprint(services) if __name__ == "__main__": app.run(debug=True, host='0.0.0.0') #app.run()
file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) from logging import Formatter mail_handler.setFormatter(Formatter(''' Message type: %(levelname)s Location: %(pathname)s:%(lineno)d Module: %(module)s Function: %(funcName)s Time: %(asctime)s Message: %(message)s ''')) if __name__ == """__main__""": # To allow aptana to receive errors, set use_debugger=False app = create_app(config="""config.yaml""") if app.debug: use_debugger = True try: # Disable Flask's debugger if external debugger is requested use_debugger = not(app.config.get('DEBUG_WITH_APTANA')) except: pass app.run(use_debugger=use_debugger, use_reloader=use_debugger, threaded=True, port=8080)
from src import app if __name__ == '__main__': app.run(debug=True, port=8000)
#!flask/bin/python from src import app app.run(debug=True,port=3030)
""" This script runs the application. """ from os import environ from src import app if __name__ == '__main__': HOST = environ.get('SERVER_HOST', 'localhost') try: PORT = int(environ.get('SERVER_PORT', '5555')) except ValueError: PORT = 5555 app.run(HOST, PORT)
def w(): app.run(debug=True)
from src import app if __name__ == '__main__': app.run(host='localhost', port=5000, debug=1)
def main(): # from werkzeug.contrib.profiler import ProfilerMiddleware # app.config["PROFILE"] = True # app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30]) app.run(host="0.0.0.0", debug=True)
from flask import Flask from src import app if __name__ == "__main__": app.run(host="0.0.0.0", port=3000, debug=True)
import os from src import app if __name__ == '__main__': port = int(os.environ.get("PORT", 5000)) app.run(host='0.0.0.0', port=port, debug=True)
import logging from logging.handlers import RotatingFileHandler from datetime import date from src import app handler = RotatingFileHandler('log_{}.log'.format( date.today().strftime('%Y-%m-%d')), maxBytes=10000, backupCount=1) formatter = logging.Formatter( "[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s") handler.setFormatter(formatter) handler.setLevel(logging.DEBUG) app.logger.addHandler(handler) app.logger.setLevel(logging.DEBUG) app.run(debug=True, host='0.0.0.0')
import os from src import app if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) # default to 5000 app.run(host='0.0.0.0', port=port)
from src import app if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=8080)
from src import app if __name__=='__main__': app.run(host='0.0.0.0')
os.path.join(result_base_dir_path, product, version, sub_version)) for sub_category in config_dir[product][sub_version].keys( ): makedir( os.path.join(result_base_dir_path, product, version, sub_version, sub_category)) for category in config_dir[product][sub_version][ sub_category]: makedir( os.path.join(result_base_dir_path, product, version, sub_version, sub_category, category)) else: for sub_category in config_dir[product][sub_version].keys( ): makedir( os.path.join(result_base_dir_path, product, version, sub_version, sub_category)) for category in config_dir[product][sub_version][ sub_category]: makedir( os.path.join(result_base_dir_path, product, version, sub_version, sub_category, category)) if __name__ == "__main__": create_directory_structure(create_file_structure) app.run(debug=True, host='0.0.0.0', port=port)
from src import app from flask import render_template import os from itsdangerous import URLSafeTimedSerializer @app.route('/') def index(): return render_template('home.html') if __name__ == '__main__': app.run(debug=True)
''' * Starting point of the application ''' # import app & configs from src import app from src.web_config import CONFIG # start the app app.run(host=CONFIG['host'], port=CONFIG['port'])
from src import app app.run(debug=True, use_reloader=False)
from src import app, db from src.models import Subject, Teacher, Group, Impart, KnowledgeArea, PDA, UniversityDegree, User, Tutorial @app.shell_context_processor def make_shell_context(): return { 'db': db, 'Subject': Subject, 'Teacher': Teacher, 'Group': Group, 'Impart': Impart, 'KnowledgeArea': KnowledgeArea, 'UniversityDegree': UniversityDegree, 'PDA': PDA, 'User': User, 'Tutorial': Tutorial, } if __name__ == '__main__': app.run(host='localhost', debug=True)
import os from src import app if __name__ == '__main__': app.run(host='0.0.0.0', port=9090, debug=True)
from src import app app.secret_key = 'super secret key' app.config['SESSION_TYPE'] = 'filesystem' app.debug = True app.run(host='127.0.0.1', port=80, debug=True) # from flask import Flask # from flask import Flask, flash, redirect, render_template, request, session, abort # import os # # app = Flask(__name__) # # # @app.route('/') # def home(): # if not session.get('logged_in'): # return render_template('login.html') # else: # return "Hello Boss!" # # # @app.route('/login', methods=['POST']) # def do_admin_login(): # if request.form['password'] == 'password' and request.form['username'] == 'admin': # session['logged_in'] = True # else: # flash('wrong password!') # return home()
from src import app app.run(debug=True, host="0.0.0.0", port=5000)
#!/usr/bin/env python3 from src import app if __name__ == "__main__": app.run()
import os from src import app port = int(os.environ.get("PORT", 5000)) app.run(host='0.0.0.0', port=port, debug=False)
groups[grp]['rules'][rule]['stats']['pass'] += 1 else: groups[grp]['rules'][rule]['stats']['fail'] += 1 groups[grp]['rules'][rule]['messages'].append({ 'message': entry['message'], 'status': entry['result'], 'region': entry['region'] }) for g in groups: groups[g]['rules'] = list(groups[g]['rules'].values()) final_result = {'results': list(groups.values())} return final_result @app.route('/rule_results') def rule_results(): # print(json.dumps(final_result)) final_result = get_run_results(res_groups, [ALL], [ALL]) return jsonify(meta="success", result=final_result) if __name__ == '__main__': #db.create_all() #db.session.close() app.run(debug=True, host='0.0.0.0', port=4000)
from src import app from src.helpers.update import update import os if os.environ.get("WERKZEUG_RUN_MAIN") == "true": update() app.run(debug=True, host='0.0.0.0', threaded=True)
from src import app if __name__ == '__main__': app.run(host='0.0.0.0', port=4000, debug=True)
#from __future__ import with_statement #<-necessary if server uses python 2.5 from flask import Flask, request, render_template import os, sys, email_fetch, db_interface from contextlib import closing from src import app #app = Flask(__name__) app.config.from_object('monitor_app_config') @app.route("/") def main(): emails = email_fetch.get_messages() return render_template('messages.html', msg=emails) if __name__ == "__main__": app.run(debug=True)
#!/usr/bin/env python3 """ Title: ATCF HTTP Server Description: A Flask-based HTTP server that returns data from the ATCF in JSON format. """ # 3rd party modules from threading import Thread # Local modules from src import ATCFServer, DevelopmentConfig, app config = DevelopmentConfig if __name__ == "__main__": Thread(target=ATCFServer, daemon=True).start() # Read class description # Server will try to use ip and port defined in .env. If not found, it will use default values Thread(app.run(host=config.FLASK_IP, port=config.FLASK_PORT, debug=config.DEBUG, use_reloader=config.RELOADER), daemon=True).start() # Flask server
import sys import os.path as op; __dir__ = op.dirname(op.abspath(__file__)) sys.path.insert(0, op.dirname(__dir__)) from src import app app.run('localhost', 5000)