Beispiel #1
0
def test_E2E():
    with open('src/test/E2E_output.txt', 'w+') as text_file:
        text_file.write('')
    app.run('src/test/E2E_input.txt', 'src/test/E2E_output.txt')
    with open('src/test/E2E_output.txt', 'r') as text_file:
        contents = text_file.read()
    assert contents == '20|toaster_1|8|SOLD|12.50|3|20.00|7.50\n20|tv_1||UNSOLD|0.00|2|200.00|150.00\n'
def run(ctx, download_to, no_download, no_parse, no_cleanup, verbose):
    """Run the app"""
    set_verbosity(verbose)

    app.run(to,
            no_cleanup=no_cleanup,
            no_download=no_download,
            no_parse=no_parse)
def main():

    loggers.standard_config()

    try:
        app.run()
    except Exception as e:
        logger.exception("Process failed.")
Beispiel #4
0
 def test_main(self):
     app.run(hidden=300,
             layer=1,
             dropout=0.0,
             learning_rate=0.01,
             iteration=5,
             save=10,
             train='./data/starwars.txt',
             test=False)
 def testDataRetrieval(self):
     keywords = [""]
     scraper = ScraperInterface(keywords)
     scraper.storeInIncidentsCollection(["Carbon Dioxide, Test Chemicals"],
                                        "12/22/2019", "Detroit",
                                        ["This is the official statement"],
                                        ["www.testUrl.com"])
     
     app.run()
Beispiel #6
0
def main(args=None):

    app.run(debug=True)

    """Console script for {{cookiecutter.lname}}."""
    click.echo("Replace this message by putting your code into "
               "{{cookiecutter.lname}}.cli.main")
    click.echo("See click documentation at http://click.pocoo.org/")
    return 0
    def test_run(self, mocked_executor):
        self.args = mock.MagicMock()
        self.args.email = "*****@*****.**"
        self.args.master = "master"
        self.args.exec_tasks = "RecipesTransformationTask"
        app.run(self.args)

        # Check only RecipesTransformationTask is called
        self.assertIn("RecipesTransformationTask", str(mocked_executor.call_args))
        self.assertNotIn("SaveRecipesParquetTask", str(mocked_executor.call_args))
    def test_default_pipeline(self, mocked_executor):
        self.args = mock.MagicMock()
        self.args.email = "*****@*****.**"
        self.args.master = "master"
        self.args.exec_tasks = ""

        app.run(self.args)
        mocked_executor.assert_called()
        self.assertIn("RecipesTransformationTask", str(mocked_executor.call_args))
        self.assertIn("SaveRecipesParquetTask", str(mocked_executor.call_args))
Beispiel #9
0
def run_app(app):
    parser = OptionParser()
    parser.add_option('-d', '--debug', dest='debug', default=False,
                      action='store_true',
                      help='Turn on debugging')
    parser.add_option('-p', '--port', dest='port', type=int, default=5000,
                      help='Specify the server port')
    parser.add_option('-l', '--listen', dest='listen_addr', default='::1',
                      help='Specify the listening address')
    options, args = parser.parse_args()
    app.run(host=options.listen_addr, port=options.port, debug=options.debug)
Beispiel #10
0
 def serve(self):
     parser = argparse.ArgumentParser(
         description='Download objects and refs from another repository')
     # NOT prefixing the argument with -- means it's not optional
     parser.add_argument('--site,s', dest='site', default='./_site')
     parser.add_argument('--hostname,h', dest='hostname', default='localhost')
     parser.add_argument('--port,p', dest='port', type=int, default=80)
     args = parser.parse_args(sys.argv[2:])
     if not os.path.isdir(args.site):
         print '\033[91m\r', 'Site directory "', args.site, '" does not exist', '\033[0m'
         return
     app.run(args.site, args.hostname, args.port)
Beispiel #11
0
def main() -> None:
    args = parse_args()
    try:
        if args.config:
            configs = load_config_file(args.config)
        else:
            configs = load_config_environ(args.debug)
    except Exception:
        print(strings.FAILED_TO_LOAD_CONFIG)
        return
    app.init(configs, debug=args.debug)
    app.run()
Beispiel #12
0
def main():
    #read config file
    conf_dic = toml.load('config.toml')
    #determine if program set for testing or deployment
    if (conf_dic['use_test'] == True):
        files = conf_dic['files']['test']
    else:
        files = conf_dic['files']['deploy']
    #extract paths for passwd and group files and port for webserver
    passwd_path = files['passwd']
    users_path = files['group']
    port = conf_dic['port']
    run(passwd_path, users_path, port)
Beispiel #13
0
def restart():
    back = input('\nWould you like to go to another calculator? y/n ')
    if back == 'y':
        print('Aight, bringing you back!')
        import app
        app.run()
    elif back == 'n':
        if e.used:
            e.wb.save('Rocket Parameters.xls')
        print('OK!')
    else:
        print('Invalid! Try Again')
        restart()
Beispiel #14
0
    def test_validate_number_in_interval_double(self):
        prod, cons = app.run(Config.K_MONITOR_TEST_TOPIC,
                             Config.PS_DATABASE_NAME,
                             Config.PS_TEST_WEBSITE_TABLE_NAME,
                             "tests/t_monitor_heavy_test.yml")

        interval = File.read_time_interval("tests/t_monitor_heavy_test.yml")

        time.sleep(interval * 2)

        app.stop_monitor(prod, cons)

        admin_client = KafkaAdminClient(
            bootstrap_servers=[Config.K_HOST + ':' + Config.K_PORT],
            security_protocol=Config.K_SECURITY_PROTOCOL,
            ssl_cafile=Config.K_SSL_CAT_FILE,
            ssl_certfile=Config.K_SSL_CERT_FILE,
            ssl_keyfile=Config.K_SSL_KEY_FILE)

        admin_client.delete_topics([Config.K_MONITOR_TEST_TOPIC])

        monitors = File.read_monitors("tests/t_monitor_heavy_test.yml")

        #send messages equals total urls count in 2 cycle is double the urls size
        self.assertEqual(prod.get_message_count(), len(monitors) * 2)
Beispiel #15
0
 async def runner():
     asyncio.create_task(app.run(loop))
     try:
         await self.start(*args, **kwargs)
     finally:
         if not self.is_closed():
             await self.close()
Beispiel #16
0
    def start(self, func=None, when_done=None, delay=0):
        assert not self.is_running()

        def default_func(thread):
            while not thread.is_stopping():
                events = yield from thread.idle()

        def default_done(future):
            app.log.future(future)

        def run():
            if delay:
                yield from asyncio.sleep(delay)
            yield from (func or default_func)(self)

        def done(future):
            self._pending.clear()
            self._scheduled.clear()
            try:
                (when_done or default_done)(future)
            except:
                app.log.exception("async: done: %r", self)
            del self._coro

        self._coro = asyncio.ensure_future(run())
        self._coro.add_done_callback(done)
Beispiel #17
0
    def test_b_corrupted_monitor_file(self):

        self.assertRaises(
            Exception, lambda: app.run(
                Config.K_MONITOR_TEST_TOPIC, Config.PS_DATABASE_NAME, Config.
                PS_TEST_WEBSITE_TABLE_NAME,
                "tests/t_monitor_corrupted_interval.yml"))
Beispiel #18
0
    def test_can_extract_transfer_and_insert_data(self):
        ''' Passes test if data is extracted, transferd and inserted in database '''

        data_before_insertion = QueryHelper.query_result_formatter(
            DatabaseHelper.select(self.select_query))

        run(self.insert_path, self.data_path)

        data_after_insertion = QueryHelper.query_result_formatter(
            DatabaseHelper.select(self.select_query))

        difference = list(
            QueryHelper.query_comparor(data_before_insertion,
                                       data_after_insertion))

        self.assertEqual(difference,
                         [['John', 'Smith', '100', 'male', 'American']])
Beispiel #19
0
async def main():
    log.init()

    log.msg('Awaiting main futures...')
    futures = [disp.run(), app.run()]
    await asyncio.wait(futures)

    log.finalize()
Beispiel #20
0
def main(argv):
    mode = ''
    try:
        opts, args = getopt.getopt(argv,"m:h",["mode="])
    except getopt.GetoptError:
        print('run.py -m <TESTING/LIVE_TESTING/TRADING/FETCH_DATA>')
        sys.exit(2)

    for opt, arg in opts:
        if opt == '-h':
            print('run.py -m <TESTING/LIVE_TESTING/TRADING/FETCH_DATA>')
            sys.exit()
        elif opt in ("-m", "--mode"):
            if arg in TradingMode.__members__:
                mode = TradingMode[arg]
            else:
                raise UnsupportedModeError(arg, "The given mode is not supported!")

    app.run(mode)
def main():
    if len(sys.argv) < 2:
        eprint("Please include a file as an argument!")
        sys.exit(1)
    
    filename = sys.argv[1]
    if not os.path.isfile(filename):
        eprint("{!r} is not a file!".format(filename))
        sys.exit(1)
    
    print(app.run(filename))
    sys.exit(0)
Beispiel #22
0
    def test_db(self):

        aiven_results = 0
        try:

            psql_conn = Database(Config.PS_DATABASE_NAME)

            print("DB Connected!")

            query = """ CREATE TABLE IF NOT EXISTS """ + Config.PS_TEST_WEBSITE_TABLE_NAME + """ (
                        name varchar(255) NOT NULL,
                        url varchar(255) NOT NULL,
                        status_code integer NOT NULL,
                        reason varchar(255) NOT NULL,
                        response_time decimal NOT NULL,
                        checked_at timestamp NOT NULL,
                        pattern varchar(255),
                        has_pattern boolean DEFAULT FALSE,
                        PRIMARY KEY(url, checked_at)
                    )  """

            psql_conn.query(query)
            print("Table created successfully in PostgreSQL ")

            query = "DELETE FROM " + Config.PS_TEST_WEBSITE_TABLE_NAME + " WHERE url = 'https://aiven.io'"
            psql_conn.query(query)

            prod, cons = app.run(Config.K_MONITOR_TOPIC,
                                 Config.PS_DATABASE_NAME,
                                 Config.PS_TEST_WEBSITE_TABLE_NAME,
                                 "tests/t_monitor_db.yml")

            print("all 'aiven.io' is deleted from PostgreSQL ")

            interval = File.read_time_interval("tests/t_monitor_corrupted.yml")

            time.sleep(interval - 1)

            app.stop_monitor(prod, cons)

            query = "SELECT * FROM " + Config.PS_TEST_WEBSITE_TABLE_NAME + " WHERE url = 'https://aiven.io'"
            cursor = psql_conn.query(query)
            aiven_results = cursor.fetchall()

            psql_conn = Database(Config.PS_DATABASE_NAME)
            query = "DROP TABLE " + Config.PS_TEST_WEBSITE_TABLE_NAME
            psql_conn.query(query)
            psql_conn.close()

        except Exception as error:
            print("Error while connecting to PostgreSQL", error)

        self.assertEqual(len(aiven_results), 1)
Beispiel #23
0
def main():
    args = sys.argv[1:]

    # env_settings
    if len(args) > 1 and args[0] in ['-e', '--env']:
        env = args[1]
        args = args[2:]
    else:
        env = 'develop'

    # help
    if len(args) > 0 and args[0] in ['-h', '--help']:
        usage_exit()

    # config_initialize
    try:
        init_config(env=env)
    except Exception as e:
        print(e)
        exit(1)

    run(env=env)
Beispiel #24
0
    def test_paging_mission_control(self):
        dirname = os.path.dirname(__file__)

        ifile = os.path.join(dirname, "data", "input.txt")
        ofile = os.path.join(dirname, "data", "output.txt")

        result = json.load(io.StringIO(app.run(ifile)))

        output = open(ofile)
        expected = json.load(output)
        output.close()

        for left, right in zip(result, expected):
            self.assertDictEqual(left, right)
Beispiel #25
0
def main():
    # Reads project-config.json
    config = pc.read()

    # Helpful variables
    tools_path = config['toolsPath']

    module_name = config['moduleName']
    module_path = config['modulePath']
    module_build_path = config['moduleBuildPath']
    module_destination_path = config['moduleDestinationPath']

    app_name = config['appName']
    app_path = config['appPath']
    app_build_path = config['appBuildPath']
    app_main_canonical_path = config['appMainCanonicalPath']

    # Module and Application build
    module.build(module_name, module_path)
    module.copy(module_name, module_build_path, module_destination_path)
    os.system(f"echo \"{bash.divider()}\"")
    app.build(app_name, app_path)
    app.install(app_name, tools_path, app_build_path)
    app.run(app_name, tools_path, app_main_canonical_path)
def Run():
  """This must be called from __main__ modules main, instead of app.run().

  app.run will base its actions on its stacktrace.

  Returns:
    app.run()
  """
  app.parse_flags_with_usage = ParseFlagsWithUsage
  original_really_start = app.really_start

  def InterceptReallyStart():
    original_really_start(main=_CommandsStart)
  app.really_start = InterceptReallyStart
  app.usage = _ReplacementAppUsage
  return app.run()
Beispiel #27
0
    def A__init__(self, schema: str = ""):

        self.webapp = run({
            "server": {
                "webserver": {
                    "name": "test_client",
                    "port": 5001,
                    "TESTING": True,
                    "reloader": False
                }
            }
        })
        self.app = self.webapp.app
        self.schema = schema

        self.init = {"headers": {'Content-Type': 'application/json'}}
def Run():
    """This must be called from __main__ modules main, instead of app.run().

  app.run will base its actions on its stacktrace.

  Returns:
    app.run()
  """
    app.parse_flags_with_usage = ParseFlagsWithUsage
    original_really_start = app.really_start

    def InterceptReallyStart():
        original_really_start(main=_CommandsStart)

    app.really_start = InterceptReallyStart
    app.usage = _ReplacementAppUsage
    return app.run()
    def test_producer_equal_consumer(self):
        prod, cons = app.run(Config.K_MONITOR_TEST_TOPIC,
                             Config.PS_DATABASE_NAME,
                             Config.PS_TEST_WEBSITE_TABLE_NAME)

        interval = File.read_time_interval()

        time.sleep(interval - 1)

        app.stop_monitor(prod, cons)

        admin_client = KafkaAdminClient(
            bootstrap_servers=[Config.K_HOST + ':' + Config.K_PORT],
            security_protocol=Config.K_SECURITY_PROTOCOL,
            ssl_cafile=Config.K_SSL_CAT_FILE,
            ssl_certfile=Config.K_SSL_CERT_FILE,
            ssl_keyfile=Config.K_SSL_KEY_FILE)

        admin_client.delete_topics([Config.K_MONITOR_TEST_TOPIC])
        self.assertEqual(prod.get_message_count(), cons.get_message_count())
Beispiel #30
0
def escritorio():
    import app
    app.run()
Beispiel #31
0
CELERY_RESULT_BACKEND = "redis://localhost:6379"


app = Flask(__name__)
app.config.from_object(__name__)
db = SQLAlchemy(app)
Bootstrap(app)

# Initialize Celery
celery = Celery(app.name, broker=app.config["CELERY_BROKER_URL"])
celery.conf.update(app.config)


from view.main.main import main

app.register_blueprint(main)


@app.errorhandler(404)
def page_not_found(error):
    return render_template("error.html", error=error)


@app.errorhandler(401)
def no_permission(error):
    return render_template("error.html", error=error)


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)
Beispiel #32
0
Routes and views for the flask application.
"""

from datetime import datetime
from flask import render_template
import app
from songdictionary import getSentValue
from songdictionary import getSongUrlFromValue
from flask import request
from flask import abort, redirect, url_for
from html_rip import link_or_nah, to_text, get_html, visible
from mood import determineSubject

if __name__ == '__main__':
    app.debut = True
    app.run(debug=True)

@app.route('/', methods=['POST', 'GET'])
def home():
    if request.method == 'POST':
        text = request.form['weblink']
        soundtype = request.form['soundtype']
        # print("from soundtype: ")
        return redirect(url_for('music', text=text, soundtype=soundtype))
    else:
        return render_template('index.html')


@app.route('/music')
def music():
    text = request.args['text']
Beispiel #33
0
def run_web():
    run()
if __name__ == "__main__":
    from {$name} import app
    from {$name}.views import *
    app.run(debug=True, host='127.0.0.1', port=5000)
Beispiel #35
0
Datei: main.py Projekt: cvan/flue
    return defaults.rating()


@app.route('/api/v1/apps/rating/<id>/flag/', methods=['POST'])
def app_rating_flag(id):
    return ''


@app.route('/api/v1/fireplace/app/<slug>/')
def app_(slug):
    return defaults.app('Something something %s' % slug, slug)


@app.route('/api/v1/installs/record/', methods=['POST'])
def record_free():
    return {'error': False}


@app.route('/api/v1/receipts/install/', methods=['POST'])
def record_paid():
    return {'error': False}


@app.route('/api/v1/apps/<id>/statistics/', methods=['GET', 'POST'])
def app_stats(id):
    return json.loads(open('./fixtures/3serieschart.json', 'r').read())


if __name__ == '__main__':
    app.run()
Beispiel #36
0
from app import run

from datetime import datetime
print "run", datetime.now().isoformat()

if __name__ == "__main__":
    run()
Beispiel #37
0
from {{APP_NAME}}.app import app
import os

if __name__ == '__main__':
    port = int(os.environ.get('PORT',5000))
    app.run(host='0.0.0.0',port=port,debug=True)
Beispiel #38
0
#!/usr/bin/python3
import app, sys
if app.run() == "Why doesn't this work!?":
    sys.exit(0)
sys.exit(1)    	
Beispiel #39
0
from {{cookiecutter.repo_name}} import app


app.run(port=9999, debug=True)
Beispiel #40
0
import os
os.environ['JAVA_HOME'] = '/usr/lib/jvm/java-11-openjdk-amd64'
os.environ['SPARK_HOME'] = '/home/michalo/spark-demo/spark-3.0.0-bin-hadoop2.7'
os.environ['HADOOP_HOME'] = os.environ['SPARK_HOME']

import findspark
findspark.init()

import app
app.run()
Beispiel #41
0
    if len(path)==1:
        path = ""

    if hd_lang.find("pt")>=0:
        return redirect("pt" + path)
    else:
        return redirect("en" + path)

@app.route('/<lang>/blog', methods=['GET'])
@app.route('/<lang>/blog/<page>', methods=['GET'])
def blog_main(lang,page=None):
    return blog.main(request,lang,page)

@app.route('/<lang>/app', methods=['GET'])
@app.route('/<lang>/app/<page>', methods=['GET'])    
def app_main(lang,page=None):
    return app.main(request,lang,page)


@app.route('/<lang>', methods=['GET','POST'])
def recruit_main(lang):       
    return recruit.main(request,lang)

@app.route('/validate_code', methods=['POST'])
def recruit_validate_code():
    return recruit.validate_code(request)  

if __name__ == '__main__':
    port = int(os.environ.get("PORT", 5000))
    app.run(host='0.0.0.0', port=port)  
Beispiel #42
0
import app
from log import lg

app = app.create_app()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
Beispiel #43
0
def serve(expenses):
    import app
    app.make_app(expenses)
    app.run(debug=False)
#    . venv/bin/activate
#    pip install -r requirements.txt
#
# Then run local_deploy.py script -
#
#    python local_deploy.py

import argparse
import logging

## LOCAL_ENV_IMPORT ##
from {{cookiecutter.app_name}}.{{cookiecutter.app_name}} import app

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='{{cookiecutter.app_description}}')

    parser.add_argument('--host', default='127.0.0.1', help='Host bind location')
    parser.add_argument('--port', default=2700, type=int, help='Port')
    parser.add_argument('--debug', default="True", type=str, help='Enable of disable debug, default True')

    args = parser.parse_args()
    args.debug = True if args.debug in ['True', 'T', 'true', 't', 'Yes', 'Y', 'yes', 'y', '1'] else False

    # Logging
    logging_format = '[%(asctime)s] %(levelname)s: %(message)s'
    logging.basicConfig(format=logging_format, level=logging.INFO)

    # Starting the application
    app.debug = args.debug
    app.run(host=args.host, port=args.port)
Beispiel #45
0
# run.py

import os

#from flasktaskr import app
import app

port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port, debug=False) 
'''Defines the run method of the Flask application. Registers the functions
`before_request()` and `after_request()` to run before and after each request,
respectively (both functions located in app/views/index). Essentially, these
functions open and close a connection to the MySQL database with each request
made to the server.
'''
from flask import Flask
from flask_json import FlaskJSON
import app
from config import *
from app import app
from app.views import *

if __name__ == '__main__':
    app.run(host=HOST, port=PORT, debug=DEBUG)
Beispiel #47
0
from python-demo.views import app

if __name__ == '__main__':
    app.run(debug=False, threaded=True, port=8090, host='0.0.0.0')
Beispiel #48
0
import app

app = app.create_app()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, debug=True)
def runserver():
    app.run(host='0.0.0.0', debug=app.config['DEBUG'])
Beispiel #50
0
def main():
    import app

    app.run()
Beispiel #51
0
# -*- coding: utf-8 -*-
import sys
import app

reload(sys)
sys.setdefaultencoding('utf-8')

app = app.create_app()

if __name__ == '__main__':
    app.run(host='0.0.0.0', debug=True)
Beispiel #52
0
from {{MODULE_NAME}}.web import app

if __name__ == '__main__':
    app.debug = True
    app.run(host='0.0.0.0', port=5001)
Beispiel #53
0
#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
Web server
"""

import os
import app
import json

URL_FILE = 'urls.json'

if __name__ == '__main__':
    # Ensure to be in the 
    os.chdir(os.path.dirname(os.path.realpath(__file__)))

    if os.path.exists(URL_FILE):
        with open(URL_FILE) as file:
            app.URLS = json.load(file)
    else:
        app.URLS = ['www.example.com']

    args = {
        'host': os.environ.get('APP_HOST', 'localhost'),
        'port': os.environ.get('APP_PORT', 8080),
        'debug': os.environ.get('APP_DEBUG', False),
    }
    app.run(**args)
Beispiel #54
0
# True if you don't run as root (you shouldn't run as root)
# be sure to add something like the following to your sudoers file:
# yourusername ALL=NOPASSWD:/etc/init.d/httpd
USE_SUDO=False

SERVICES= {
	# Edit these services to match the ones you want to manage
	'apache2': {
		'title': 'Apache Web Server',
		'ops': ['status', 'stop','start','graceful'],
		'status': 'status'
	},
	'ssh': {
		'title': 'SSH Server',
		'ops': ['status','stop','start','restart'],
		'status': 'status'
	},
}

LOGINS = {
	# username and password hash
	# Generate new password hashes by running ./webinitd.py --password yourpasswordhere
	'admin': 'sha256:1024:C6vwpHVe:H9QumIJLvdQeb7ZR2izY092umM9TPqPlgVaPZRGeZiY=',
}


if __name__=="__main__":
	import app
	app.run(USE_SUDO,SERVICES,LOGINS)
Beispiel #55
0
def runserver(t):
	import app
	app.run(host="0.0.0.0")
Beispiel #56
0
 def test_run(self):
     app.run()
     self.assertTrue(True)
        show this help
    -p [port]
        use this port
    -s [ip]
        bind this ip
"""
import sys
import getopt

if __name__ == "__main__":
    try:
        opts, args = getopt.getopt(sys.argv[1:], "hp:s:")
    except getopt.GetoptError as err:
        print str(err)
        print __doc__
        sys.exit(2)

    port = None
    ip = '0.0.0.0'
    for o, a in opts:
        if o == '-h':
            print __doc__
            sys.exit(1)
        elif o == '-p':
            port = int(a)
        elif o == '-s':
            ip = a

    from <%= packageName %>.basemain import app
    app.run(debug=True, host=ip, port=port)
Beispiel #58
0
# -*- coding: utf-8 -*-

"""
    ~~ BeyondCP - run.py ~~

@author         WoodyTheWoo
@licence        2014
@version        v 0.1
"""

from os.path import exists

from apscheduler.scheduler import Scheduler

from app import run
from database import db_create_table, DATABASE_PATH


if __name__ == "__main__":
    if exists(DATABASE_PATH):
        print("Database OK")
    else:
        print("Database KO")
        db_create_table()

    sched = Scheduler()
    # sched.add_interval_job(hello, seconds=1)

    sched.start()
    run(host='0.0.0.0', debug=True)
Beispiel #59
0
		prediction=rfmodel.predict(dff)
		
		
		if(prediction==-1):
			d_entry=open('blacklist.txt','a')
			d_entry.write("\n")
			d_entry.write(url)
			d_entry.close()
			value="Phishing Website"
			return render_template("home.html",error=value)
			
		elif(rank==-1):
			d_entry=open('blacklist.txt','a')
			d_entry.write("\n")
			d_entry.write(url)
			d_entry.close()
			value="Phishing Website"
			return render_template("home.html",error=value)
		else:
			value=url+""+" is not Phishing Website!!"
			return render_template("home.html",error=value)
@app.route('/getAbout')
def getAbout():
	return render_template('about.html')
@app.route('/getAbout1')
def getAbout1():
	return render_template('about1.html')

if __name__=="__main__":
	app.run(debug=True)
	
Beispiel #60
0
def run():
    """
    Run app in debug mode (for development).
    """
    app.run()