session["user_id"] = str(check.user_id)
response["success"] = 'True'
response["message"] = "You've logged in!"
else:
response["success"] = 'False'
response["message"] = "That was the wrong password!"
else:
new = User.new_user(email, pword, nickname)
session["user_id"] = new["id"]
response["message"] = new["message"]
return jsonify(response)
@app.route('/loggout.json')
def loggout_user():
"""ajax call for loggout"""
response = {}
del session["user_id"]
response["message"] = "You're now logged out"
return jsonify(response)
if __name__ == "__main__":
app.debug = True
app.jinja_env.auto_reload = app.debug
connect_to_db(app)
http_server = WSGIServer(('0.0.0.0', 5000), app)
http_server.serve_forever()
DebugToolbarExtension(app)
# download images
print 'Downloading for %s started: %d sec improc_timeout, %d sec per_image_timeout' % (
query, imgetter_params['improc_timeout']
if imgetter_params['improc_timeout'] else -1,
imgetter_params['per_image_timeout']
if imgetter_params['per_image_timeout'] else -1)
dfiles_list = http_service_helper.imsearch_download_to_static(
query_res_list, postproc_module, postproc_extra_prms,
custom_local_path, imgetter_params, zmq_context)
print 'Downloading for %s completed: %d images retrieved' % (
query, len(dfiles_list))
# convert pathnames to URL paths (if not running locally and specifying
# a custom path)
if not custom_local_path:
dfiles_list = http_service_helper.make_url_dfiles_list(dfiles_list)
if return_dfiles_list:
return Response(json.dumps(dfiles_list), mimetype='application/json')
else:
return 'DONE'
if __name__ == '__main__':
if len(sys.argv) > 1:
SERVER_PORT = int(sys.argv[1])
else:
SERVER_PORT = DEFAULT_SERVER_PORT
print "Starting imsearch_http_service on port", SERVER_PORT
http_server = WSGIServer(('', SERVER_PORT), app)
http_server.serve_forever()
str = ''
for char in chars:
str += chr(97 + int(char))
r.hset('links', str, request.form['url'])
return str, 200
@app.route('/<link>')
def get_link(link):
if app.config['ENABLE_EVIL'] and random.randint(
0, 100) <= app.config['EVIL_LEVEL']:
evil_sites = [
# Put your evil sites here...
]
return redirect(random.choice(evil_sites))
url = r.hget('links', link)
if url:
return redirect(url)
else:
return abort(404)
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('', app.config['APP_PORT']), app)
http_server.serve_forever()
# Lancement du serveur
if "tornado" in sys.argv:
# Serveur Tornado
# Installation préalable : "pip install tornado"
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(port)
IOLoop.instance().start()
elif "gevent" in sys.argv:
# Serveur Gevent
# Installation préalable : "pip install gevent"
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('', port), app)
http_server.serve_forever()
else:
# Serveur intégré à Flask
app.run(host=host, port=port, debug=False)
"""Entrypoint to start app."""
from gevent.wsgi import WSGIServer
import logging
from dasem.app import create_app
logging_level = logging.DEBUG
logger = logging.getLogger()
logger.setLevel(logging_level)
logging_handler = logging.StreamHandler()
logging_handler.setLevel(logging_level)
logging_formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logging_handler.setFormatter(logging_formatter)
logger.addHandler(logging_handler)
logger.info('Logging setup')
logger.info('Creating app')
app = create_app()
# WSGIServer server better than werkzeug
# http://stackoverflow.com/questions/37962925/
http_server = WSGIServer(('', 5000), app, log=logger)
http_server.serve_forever()
def main(argv=None):
parser = ArgumentParser(description="pistat.py [options]")
parser.add_argument("-c",
"--config",
dest="config",
default=DEFAULT_CONFIG_FILE,
action="store",
help="App config file")
parser.add_argument("-d",
"--debug",
dest="debug",
default=False,
action="store_true",
help="Run app in debug mode")
parser.add_argument("-s",
"--console",
dest="console",
default=False,
action="store_true",
help="Log to console")
parser.add_argument("-p",
"--port",
dest="port",
default=5337,
type=int,
action="store",
help="Port number to run on")
options = parser.parse_args()
if not os.path.exists(options.config):
print 'Supplied config file \'%s\' does not exist' % options.config
sys.exit(1)
webapp = Flask(__name__)
webapp.config.update(json.load(open(options.config)))
root_log = logging.getLogger()
formatter = logging.Formatter(
"%(asctime)s %(levelname)-5s %(name)s(:%(lineno)d) %(message)s",
'%Y.%m.%d-%H:%M:%S')
if options.debug:
root_log.setLevel(logging.DEBUG)
else:
root_log.setLevel(logging.INFO)
if options.console:
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
root_log.addHandler(console_handler)
file_handler = RotatingFileHandler(webapp.config['log_file'],
maxBytes=10240000,
backupCount=5)
file_handler.setFormatter(formatter)
root_log.addHandler(file_handler)
logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING)
setup_routes(webapp)
setup_db(webapp)
log.info("Starting pistat on %s | config file: %s | debug: %s",
options.port, options.config, options.debug)
if options.debug:
webapp.debug = True
webapp.run(host='0.0.0.0', port=options.port)
else:
http_server = WSGIServer(('', options.port), webapp, log=None)
http_server.serve_forever()
def run(self, handler):
from gevent import monkey
monkey.patch_socket()
from gevent.wsgi import WSGIServer
WSGIServer((self.host, self.port), handler).serve_forever()
def run(self):
self.httpServer = WSGIServer(("0.0.0.0", self.port),
self.mainServer.app,
log=None)
self.httpServer.serve_forever()
"%s, try to pip install setproctitle, otherwise, you can't use the process to customize the function"
% e)
else:
setproctitle.setproctitle(ProcessName)
msg = "The process is %s" % ProcessName
print(msg)
logger.info(msg)
try:
msg = "%s has been launched, %s:%d, with %s." % (ProcessName, Host, Port,
ProductType)
print(msg)
logger.info(msg)
if ProductType == 'gevent':
from gevent.wsgi import WSGIServer
http_server = WSGIServer((Host, Port), app)
http_server.serve_forever()
elif ProductType == 'tornado':
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(Port)
IOLoop.instance().start()
else:
msg = 'Start the program does not support with %s, abnormal exit!' % ProductType
logger.error(msg)
raise RuntimeError(msg)
from gevent.wsgi import WSGIServer
from app import app, blueprint
http_server = WSGIServer(('127.0.0.1', 8401), app)
http_server.serve_forever()
if sys.argv[1].startswith('main'):
from main import app
elif sys.argv[1].startswith('chat'):
from chat import app
except ImportError:
sys.exit("Usage: python run_server.py (main|chat) [--debug]")
if '--debug' in sys.argv:
app.debug = True
socket_path = '/tmp/'+sys.argv[1]+'.sock'
# Delete the socket file if it already exists.
try:
os.remove(socket_path)
except OSError:
pass
sock = socket(AF_UNIX)
sock.bind(socket_path)
sock.setblocking(0)
sock.listen(256)
os.chmod(socket_path, 0777)
http_server = WSGIServer(sock, app)
# yeah this is a hack.
http_server.environ['SERVER_NAME'] = getfqdn()
http_server.serve_forever()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from gevent.wsgi import WSGIServer
from gevent import monkey
monkey.patch_all()
import requests
from flask import Flask, json
from settings import SPARQL_ENDPOINT
from queries import GET_QUERY
app = Flask(__name__)
app.debug = False
@app.route('/')
def get():
payload = {"query": GET_QUERY, "format": "application/sparql-results+json"}
r = requests.get(SPARQL_ENDPOINT, params=payload)
return r.text
if __name__ == "__main__":
http_server = WSGIServer(('', 8888), app)
http_server.serve_forever()
os.remove(file_path)
return mp4_path
def reply_func(self, param_dict):
msg = param_dict['Content']
if u'拍照' in msg:
param_dict['Content'] = u'请耐心等待拍照'
self.queue.put(['image', param_dict['FromUserName']])
elif u'视频' in msg:
param_dict['Content'] = u'请耐心等待视频录制, 若想查看实时视频流(可能较卡), ' \
u'请访问: http://pi.finaltheory.me'
self.queue.put(['video', param_dict['FromUserName']])
else:
param_dict['Content'] = u'无法理解您的要求'
return param_dict
if __name__ == '__main__':
monitor = MonkeyMonitor()
# 实例化自动回复类
server = MonkeyServer('monitor')
# 注册回调函数
server.register_callback('text', monitor.reply_func)
# 使用gevent启动服务器实例
http_server = WSGIServer(('', 8000), server.app)
try:
http_server.serve_forever()
except KeyboardInterrupt as e:
sys.stderr.write(e.message + '\n')
monitor.queue.put(None)
def main():
args = docopt(__doc__, version='zenfeed ' + VERSION)
log_arg, log_level = args['--log'].rsplit(':', 1)
if log_arg not in ('stderr', 'syslog'):
setup_logger(type='file',
filename=path(log_arg).abspath(),
level=log_level)
else:
setup_logger(type=log_arg, level=log_level)
logger.info('Zenfeed %s booting...', VERSION)
if args['genstatic']:
return genstatic(args['PATH'])
port = int(args['--port'])
cache_disabled = args['--no-cache']
path_prefix = args['--prefix']
if path_prefix.endswith('/'):
path_prefix = path_prefix[:-1]
if path_prefix and not path_prefix.startswith('/'):
path_prefix = '/' + path_prefix
fixed_language = args['--lang']
if fixed_language == 'browser':
fixed_language = None
else:
logger.info('Language fixed to "%s"', fixed_language)
if (fixed_language not in LANGUAGES
and fixed_language.split('_', 1)[0] not in LANGUAGES):
return logger.critical('Fixed language not supported !')
fixed_timezone = args['--tz']
logger.info('Timezone fixed to "%s"', fixed_timezone)
if fixed_timezone not in all_timezones:
return logger.critical('Fixed timezone not supported !')
db_uri = args['--database']
if db_uri == ':memory:':
db_uri = 'sqlite://'
elif not "://" in db_uri:
db_uri = 'sqlite:///%s' % path(db_uri).abspath()
import app as app_module
app = app_module.create_flask_app(prefix=path_prefix)
app.config.update(
DEBUG=args['--debug'],
SQL_DEBUG=False,
SECRET_KEY=urandom(32),
SQLALCHEMY_DATABASE_URI=db_uri,
FAVICON_DIR=path(args['--favicons']).abspath(),
FIXED_LANGUAGE=fixed_language,
FIXED_TIMEZONE=fixed_timezone,
CACHE_ENABLED=not cache_disabled,
PATH_PREFIX=path_prefix,
)
Cache(app)
from models import setup_tables, Feed
patch_socket()
patch_ssl()
setup_tables()
from deadline_manager import deadlineManager
import views
from werkzeug.contrib.fixers import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
feeds = Feed.query.all()
deadlineManager.favicon_dir = path(args['--favicons']).abspath()
deadlineManager.launch_deadline_workers(feeds)
deadlineManager.start()
logger.info("Server started at port %d (prefix: %s/)", port, path_prefix)
if args['--debug']:
logger.warning("DEBUG mode activated")
app.run(host='0.0.0.0', port=port, debug=True)
else:
from gevent.wsgi import WSGIServer
http_server = WSGIServer(('0.0.0.0', port), app)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
with open('resource/url.txt') as f:
str_ = f.read()
url_list = json.loads(str_)
print('url_list len', len(url_list))
return url_list
def page_url(page):
n = 20
page = int(page)
url_list = url_array()
url_list_split = [url_list[i:i + n] for i in range(0, len(url_list), n)]
return url_list_split[page]
@app.route('/images', methods=['GET'])
def images():
args = request.args
page = args['page']
p_url = page_url(page)
return json.dumps(p_url)
@app.route(
'/<path:fn>', )
def file(fn):
return send_file(fn)
WSGIServer(('', 9393), app).serve_forever()
# Comment out for running locally
@app.route('/{0}'.format(UPLOAD_PATH), methods=['POST'])
def upload_result():
data = request.files['data']
if os.path.splitext(data.filename)[1] == '.png':
data.save('static/' + data.filename)
elif os.path.splitext(data.filename)[1] == '.txt':
with open('backend/log/' + data.filename, 'a') as logfile:
logfile.write(data.stream.read())
return ''
# ----------
@app.route('/adv/')
def adv_mode():
if 'advmode' in session: session.pop('advmode', None)
else: session['advmode'] = '1'
return redirect(url_for('index'))
if __name__ == "__main__":
http_server = WSGIServer(('0.0.0.0', 8080), app)
http_server.serve_forever()
# -*- coding: utf-8 -*-
__author__ = 'Administrator'
from gevent.wsgi import WSGIServer
from main_web import app
if __name__ == '__main__':
http_server = WSGIServer(('', 8001), app)
http_server.serve_forever()
missing = missing
if missing > 0:
return False
else:
return True
@app.route('/api')
def api():
if request.environ.get('wsgi.websocket'):
ws = request.environ['wsgi.websocket']
while True:
email = ws.receive()
if email in webSockets:
webSockets[email].send("signOutNow")
webSockets[email] = ws
return "OK"
# last line adds the email to webSocket
# need something that checks if user online, something that adds to "webSockets" when login? removes from "webSockets?
# or do you want to use the users_loggedin table?
if __name__ == '__main__':
#app.run(host='127.0.0.1', port=5001)
app.debug = True
http_server = WSGIServer(('', 5169), app, handler_class=WebSocketHandler)
http_server.serve_forever()
def gen():
q = Queue()
subscriptions.append(q)
try:
# while True:
end = time.time() + 60
while time.time() < end:
result = q.get()
print "result", result
ev = ServerSentEvent(str(result))
yield ev.encode()
sleep(0.3)
# Keep connection alive no more then... (s)
except GeneratorExit: # Or maybe use flask signals
subscriptions.remove(q)
return Response(gen(), mimetype="text/event-stream")
@app.route('/stream')
def stream():
return Response(event_stream(), mimetype="text/event-stream")
if __name__ == "__main__":
app.debug = False
server = WSGIServer(("", 5001), app)
server.serve_forever()
# app.run(host='0.0.0.0',port=5001,debug=True)
# Then visit http://localhost:5000 to subscribe
# and send messages by visiting http://localhost:5000/publish
def main():
port = int(os.getenv('FLASK_PROXY_PORT', 8080))
server = WSGIServer(('', port), proxy, log=None)
server.serve_forever()
def serve_forever(listener):
WSGIServer(listener, application, spawn=Pool(), log=None).serve_forever()
from gevent.wsgi import WSGIServer
import ghdata
http_server = WSGIServer(('', 5001), ghdata.server.app)
http_server.serve_forever()
def main(): # pragma: no cover
logger.info('Starting Server')
http_server = WSGIServer(('0.0.0.0', 8080), app)
http_server.serve_forever()
autocomplete_results = es.search(
index=ES_INDEX,
body=build_autocomplete_search_body_request(query, category, field))
return jsonify(
{"results": format_autocomplete_results(autocomplete_results, field)})
# make static assets available
@app.route('/assets/<path:path>')
def send_static(path):
return send_from_directory('build', path)
# render user interfaces in client JS
@app.route('/')
@app.route('/about')
@app.route('/help')
@app.route('/search')
def react_render():
return render_template('index.jinja2')
if __name__ == '__main__':
if os.environ.get('PRODUCTION', ''):
http_server = WSGIServer(('', 5000), app)
http_server.serve_forever()
else:
app.run(debug=True)
def startserver(adduser, api, auth, hydradoc, port, serve):
"""Python Hydrus CLI"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = 'sqlite:///:memory:'
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "http://localhost:" + str(port) + "/"
# The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample]
click.echo("Creating the API Documentation")
apidoc = doc_maker.create_doc(json.loads(hydradoc.read()),
HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
classes = doc_parse.get_classes(
apidoc.generate()
) # You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
getter_setter = Getter_setter(session, HYDRUS_SERVER_URL, API_NAME, apidoc,
True)
print("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME, getter_setter)
# Set the name of the API
print("Starting the application")
http_server = WSGIServer(('', 8080), app)
print("Server running at:")
print(HYDRUS_SERVER_URL + API_NAME)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
def __init__(self, client, config=None):
self.client = client
self.config = config or BotConfig()
# Shard manager
self.shards = None
# The context carries information about events in a threadlocal storage
self.ctx = ThreadLocal()
# The storage object acts as a dynamic contextual aware store
self.storage = None
if self.config.storage_enabled:
self.storage = Storage(self.ctx,
self.config.from_prefix('storage'))
# If the manhole is enabled, add this bot as a local
if self.client.config.manhole_enable:
self.client.manhole_locals['bot'] = self
# Setup HTTP server (Flask app) if enabled
self.http = None
if self.config.http_enabled:
try:
from flask import Flask
except ImportError:
self.log.warning(
'Failed to enable HTTP server, Flask is not installed')
else:
self.log.info('Starting HTTP server bound to %s:%s',
self.config.http_host, self.config.http_port)
self.http = Flask('disco')
self.http_server = WSGIServer(
(self.config.http_host, self.config.http_port), self.http)
self.http_server_greenlet = gevent.spawn(
self.http_server.serve_forever)
self.plugins = {}
self.group_abbrev = {}
# Only bind event listeners if we're going to parse commands
if self.config.commands_enabled:
self.client.events.on('MessageCreate', self.on_message_create)
if self.config.commands_allow_edit:
self.client.events.on('MessageUpdate', self.on_message_update)
# If we have a level getter and its a string, try to load it
if isinstance(self.config.commands_level_getter, six.string_types):
mod, func = self.config.commands_level_getter.rsplit('.', 1)
mod = importlib.import_module(mod)
self.config.commands_level_getter = getattr(mod, func)
# Stores the last message for every single channel
self.last_message_cache = {}
# Stores a giant regex matcher for all commands
self.command_matches_re = None
# Finally, load all the plugin modules that where passed with the config
for plugin_mod in self.config.plugins:
self.add_plugin_module(plugin_mod)
# Convert level mapping
for k, v in list(six.iteritems(self.config.levels)):
self.config.levels[int(k) if k.isdigit(
) else k] = CommandLevels.get(v)
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_1)
else:
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
if isfile(config.certificatePath) and isfile(config.privateKeyPath):
context.load_cert_chain(config.certificatePath,
config.privateKeyPath)
return context
else:
flaskServer.displayIfFileNotFound(config.certificatePath)
flaskServer.displayIfFileNotFound(config.privateKeyPath)
return None
if __name__ == "__main__":
case_database.initialize()
ssl_context = get_ssl_context()
try:
port = int(config.port)
host = config.host
if ssl_context:
server = WSGIServer((host, port),
application=flaskServer.app,
ssl_context=ssl_context)
else:
server = WSGIServer((host, port), application=flaskServer.app)
print('Listening on host ' + host + ' and port ' + str(port) + '...')
server.serve_forever()
except ValueError:
print('Invalid port {0}. Port must be an integer'.format(config.port))
def run_app(app, port=5000):
http_server = WSGIServer(('', port), app)
webbrowser.open_new('http://localhost:' + str(port))
http_server.serve_forever()
return jsonify(current_app.data_router.get_status())
@rasa_nlu_app.route("/", methods=['GET'])
def hello():
return "hello from Rasa NLU: " + __version__
@rasa_nlu_app.route("/train", methods=['POST'])
@requires_auth
def train():
data_string = request.get_data(as_text=True)
current_app.data_router.start_train_process(data_string, request.args)
return jsonify(info="training started. Current pids: {}".format(current_app.data_router.train_procs))
logging.basicConfig(filename=config['log_file'], level=config['log_level'])
logging.captureWarnings(True)
logging.info("Configuration: " + config.view())
logging.debug("Creating a new data router")
rasa_nlu_app.data_router = DataRouter(config, component_builder)
return rasa_nlu_app
if __name__ == '__main__':
# Running as standalone python application
arg_parser = create_argparser()
cmdline_args = {key: val for key, val in list(vars(arg_parser.parse_args()).items()) if val is not None}
rasa_nlu_config = RasaNLUConfig(cmdline_args.get("config"), os.environ, cmdline_args)
app = WSGIServer(('0.0.0.0', rasa_nlu_config['port']), create_app(rasa_nlu_config))
logging.info('Started http server on port %s' % rasa_nlu_config['port'])
app.serve_forever()
def main(args):
# Executing this file with no extra options runs the simple service with the bidaf test fixture
# and the machine-comprehension predictor. There's no good reason you'd want
# to do this, except possibly to test changes to the stock HTML).
parser = argparse.ArgumentParser(description='Serve up a simple model')
parser.add_argument('--archive-path',
type=str,
help='path to trained archive file')
parser.add_argument('--predictor', type=str, help='name of predictor')
parser.add_argument('--static-dir',
type=str,
help='serve index.html from this directory')
parser.add_argument('--title',
type=str,
help='change the default page title',
default="QA Chatbot")
parser.add_argument('--field-name',
type=str,
action='append',
help='field names to include in the demo')
parser.add_argument('--include-package',
type=str,
action='append',
default=[],
help='additional packages to include')
args = parser.parse_args(args)
# Load modules
for package_name in args.include_package:
import_submodules(package_name)
# trained_models = Dict[str, DemoModel]
# print(trained_models)
# predictors = {}
# for name, demo_model in trained_models.items():
# predictor = demo_model.predictor()
# predictors[name] = predictor
#
# model = predictors.get(model_name.lower())
archive = load_archive(
args.archive_path or
'tests/fixtures/bidaf/serialization/bidaf-model-2017.09.15-charpad.tar.gz'
)
global predictor
predictor = Predictor.from_archive(
archive, args.predictor or 'machine-comprehension')
# field_names = args.field_name or ['passage', 'question']
field_names = args.field_name or ['passage']
app = make_app(predictor=predictor,
field_names=field_names,
static_dir=args.static_dir,
title=args.title)
http_server = WSGIServer(('0.0.0.0', 8000), app)
http_server.serve_forever()
