def run(self):
log = get_log("daemon")
import server
try:
server.run()
except:
log.exception()
def run(params , options):
"""
"""
if len(params) and params[0].isdigit():
server.run(int(params[0]))
else:
server.run()
def server_thread_rountine():
self._thread_started_cond.acquire()
self._thread_started_cond.notify()
self._thread_started_cond.release()
with patch('smartbus.ipcclient.Client') as mock_smbipc_cls:
mock_smbipc_cls.__lib = True
mock_smbipc_cls.initialize = MagicMock(return_value=True)
server.run(prog_args)
def run():
if not 'CONDUCTOR_CONFIG' in os.environ:
raise RuntimeError("CONDUCTOR_CONFIG is not set in the environment. Please contact Conductor support for help configuring Conductor Client")
if webbrowser.open('http://localhost:8085/index.html', new=1, autoraise=True):
server.run(port=8085)
else:
raise RuntimeError ("Unable to open web browser. Please contact Conductor support for help configuring Conductor Client")
def next_round(board, links, scores):
move = clients.Enemy.run(board, 1)
board, links, scores[0], won = server.run(board, links, scores[0], move, 1)
move = clients.Enemy.run(board, 2) # move = AI.run(board)
board, links, scores[1], won = server.run(board, links, scores[1], move, 2)
return board, links, scores, won
def main():
parser = argparse.ArgumentParser(description='Run the bycombat server.')
parser.add_argument('--build', choices=['debug', 'release'], default='debug', required=False, help='build to run with server')
parser.add_argument('--debug', action='store_const', const='debug', dest='build', help='run debug server using local cocos project')
parser.add_argument('--release', action='store_const', const='release', dest='build', help='run release server using built cocos project')
parser.add_argument('--port', type=int, dest='port', default=5000, help='run the server on a different port')
args = parser.parse_args()
debug = args.build == 'debug'
port = args.port
print('Running server in {} mode'.format(args.build))
server.run(debug, port)
def run_server():
import server
log('run server...')
cfg = read_config()
try:
while True:
server.run('res\\packages', cfg['address'], cfg['port'])
log('stopped, restarting...')
except:
log('* Crashed *')
import traceback
traceback.print_exc()
log('Server stopped!')
def _run(self):
self.gameOn = True
while self.gameOn:
run()
dt = fpsClock.tick(30)
#Inputs
self.inputManager.update()
#Updates
self.update(dt)
#Renders, put in the screen
self.render()
def test_run(mock_make_server, mock_get):
mock_server = mock.MagicMock()
mock_make_server.return_value = mock_server
mock_get.return_value = fake_response(200, '{"FileStatuses": {"FileStatus": []}}')
server.run(['server.py'])
mock_make_server.assert_called_once_with('0.0.0.0', 9876, mock.ANY)
mock_server.serve_forever.assert_called_once_with()
mock_get.assert_called_once_with(
'http://localhost:14000/webhdfs/v1/?user.name=igv&op=liststatus')
mock_make_server.reset_mock()
mock_server.reset_mock()
mock_get.reset_mock()
server.run(['server.py', '1234'])
mock_make_server.assert_called_once_with('0.0.0.0', 1234, mock.ANY)
mock_server.serve_forever.assert_called_once_with()
mock_get.assert_called_once_with(
'http://localhost:14000/webhdfs/v1/?user.name=igv&op=liststatus')
def run_text_interface():
"""
takes command line input
"""
prompt = "press 1 to start a group chat\n" \
"press 2 to join a group chat\n" \
"press 3 to quit\n" \
"> "
# wait for the user to choose an option
choice = ""
while choice != "1" and choice != "2" and choice != "3":
choice = raw_input(prompt)
print ""
# run the selected option
if choice == "1":
server.run()
if choice == "2":
config.set_voice()
client.run()
elif choice == "3":
sys.exit()
from server import run, application if __name__ == '__main__': print 'run as standalone version' run() else: print 'run as embedded version'
def smc_server(args):
run("localhost", 5000, args)
import argparse
import server
if __name__ == '__main__':
try:
parser = argparse.ArgumentParser(description="ftp client")
parser.add_argument("-e", "--encoding", default="utf-8", help="encoding for text data")
parser.add_argument("server_address")
parser.add_argument("-p", "--port", default=21)
parser.add_argument("--ya", help="change code in letter я", default=False, action='store_true')
args = parser.parse_args()
server.run(args.server_address, int(args.port), args.encoding, args.ya)
except UnicodeDecodeError:
print("the current encoding is not supported")
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version,
program_build_date)
program_license = '''SmartBus Remote Method Provider for IPSC CTI server.
Created by [email protected] on %s.
Copyright 2014 Hesong(GuangZhou) Info-Tech. All rights reserved.
USAGE
''' % (str(__date__))
program_runtime_message = '''
runtime:
executable: {}
version: {}
platform: {}
path:
{}
'''.format(sys.executable, sys.version, sys.platform,
(os.linesep + ' ').join(sys.path))
globalvars.startuptxt = '''
{}
{}
version : {}
date : {}
update : {}
'''.format(program_version_message, program_runtime_message, __version__,
__date__, __updated__)
try:
# Setup argument parser
parser = ArgumentParser(description=program_license,
formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-V',
'--version',
action='version',
version=program_version_message)
parser.add_argument("-v",
"--verbose",
action="store_true",
help="output verbose logging text.")
parser.add_argument(
'-W',
'--no-web-server',
action='store_true',
help="run the program without starting the web server.")
# Process arguments
args = parser.parse_args()
# set INTERRUPT signal handler
def handle_sigint(signum, frame):
print('SIGINT handled!')
server.stop()
signal.signal(signal.SIGINT, handle_sigint)
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except Exception as e:
if DEBUG or TESTRUN:
raise (e)
indent = len(program_name) * " "
sys.stderr.write(program_name + ": " + repr(e) + "\n")
sys.stderr.write(indent + " for help use --help" + "\n")
return 2
# startup server
print('startup server')
server.run(args)
print('program terminated')
return 0
def worker_run(loop, server_sock):
loop.run_until_complete(run(loop, server_sock, engine))
pymonzo.monzo_api.config.REDIRECT_URI = 'http://127.0.0.1:8080/monzo/auth'
# Read the api_info.conf
conf = ConfigParser()
conf.read('api_info.conf')
data = dict(conf.items('monzo'))
# Build up the URL to get the token
url = 'https://auth.monzo.com/?client_id={}&response_type=code&redirect_uri={}&state={}'
redirect_url = pymonzo.monzo_api.config.PYMONZO_REDIRECT_URI
state = uuid.uuid4()
state = '{}'.format(state)
print url.format(data['client_id'], redirect_url, state)
# Wait for the server to respond
httpd = server.run(port=8080, serve=False)
httpd.serve_forever(poll_interval=0.5)
# Check that the server.state and state_id are the same. If they aren't, abort!
if server.state != state:
print 'States don\'t match :( aborting.'
else:
# Setup authenticating using the auth_code
data['auth_code'] = server.code
api = pymonzo.MonzoAPI(client_id=data['client_id'],
client_secret=data['client_secret'],
auth_code=data['auth_code'])
# Show whoami() to prove we have authenticated correctly.
print api.whoami()
try:
import config
print('[Info] Loading configuration from config.py')
Server = config.Server
Dashboard = config.Dashboard
Worker = config.Worker
except ImportError:
print('[Warning] No configuration file were found! Using default config settings.')
print('[Warning] For more info see config.py. example file or README file.')
Server = None
Dashboard = None
Worker = None
if len(sys.argv) < 2:
sys.exit('Usage: %s component-name (i.e. server, dashboard or worker)' % sys.argv[0])
elif (sys.argv[1] == 'worker'):
print 'running worker'
import worker
worker.run(Worker)
elif (sys.argv[1] == 'dashboard'):
print 'running dashboard'
import dashboard
dashboard.run(Dashboard)
elif (sys.argv[1] == 'server'):
print 'running server'
import server
server.run(Server)
else:
sys.exit('Usage: %s component-name (i.e. server, dashboard or worker)' % sys.argv[0])
@app.route("/statistics/", methods=["GET"])
@returnHTML
def fz_statistics_page():
return "statistics.html"
# poem
@app.route("/poem/", methods=["GET", "POST"])
@jsut4test
@returnjson
def poem_action():
from poem import PoemHandler
poemHandler = PoemHandler()
return poemHandler.get_poem_info()
# CBDB
@app.route("/cbdb/", methods=["GET"])
@tryredirect
def cbdb_action():
from cbdb import CBDB
cbdb = CBDB()
return cbdb.get_redirect_url_for_person()
if __name__ == "__main__":
#app.run(host = "0.0.0.0", port = 8080, debug = True)
import server
server.run(True)
def main():
server = CounterServer("compteur.notaname.fr", 8080)
server.run()
self.add(self.state)
return self.state
@authenticated(["__has_ssl__"])
def set_state(self, request, state):
print "Setting state to", request,state
self.state = state
return self.state
# class MyOtherActuator(ContinuousActuator):
# def get_state(self, request):
# return self.state
# def set_state(self, request, state):
# print "Setting state to", state
# self.state = state
act = MyActuator(inst.uuid('/a1'), 'UoM')
import actuate
inst.add_timeseries('/a1', act)
inst.add_timeseries('/t1', 'V')
rl = RateLimiter(10)
a2 = inst.add_actuator('/a2', 'UoM', MyActuator,
read_limit=10,
write_limit=10,
setup={})
server.run(inst, port=8080)
# a = MyActuator()
# b = MyOtherActuator(range=[0, 5])
# SmapHttp.start_server({'a': a, 'b': b}, port=8000, handler=SmapHttp.SslSmapHandler)
def test_run(self):
server.run()
def server_function():
while True:
server.run()
from server import run
if __name__ == '__main__':
config = dict(
host='0.0.0.0',
port=2000,
)
run(**config)
#! /usr/bin/env python3
import args
import server, client
if __name__ == '__main__':
(listen_port, remote_host, remote_port, files) = args.check_args()
# user may pass listen port 0
if listen_port != None:
server.run(listen_port, files)
else:
client.run(remote_host, remote_port, files)
if not args.addr:
print("No address specified, using localhost {}".format(
socket.gethostname()))
args.addr = socket.gethostname()
if not (args.dest ^ args.source):
print("Directory must be either the source or the destination")
print("Exactly one of --source or --dest must be set")
if args.source:
# Set up socket to send data
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("Connecting to {} on port {}".format(args.addr, args.port))
try:
sock.connect((args.addr, args.port))
except ConnectionRefusedError:
print(
"Could not Connect to server, check port {} and address {} are correct"
.format(args.port, args.addr))
print("and that the server is running.")
exit()
dir_status = get_directory_status(args.dir)
requested_files = send_status(sock, dir_status)
print("Received response {}".format(requested_files))
send_files(sock, [os.path.join(args.dir, f) for f in requested_files])
sock.close()
if args.dest:
import server
server.run(args.port, args.dir)
seeds = value.split( ',') if name == "--load-limit": load_limit = value if name == "--bootstrap": load_limit = None if name == "--bootstrap-limit": bootstrap_limit = value if name == "--rm-limit": rm_limit = value host, port = helpers.normalize_addr( bind) if host is None: die( 'Invalid binding address %s'%bind) sync.init_cluster_state( '%s:%s'%(host, port)) # FIXME avoid adding these seeds in cluster for seed in seeds: r = sync.cluster_state.add_instance( seed) # Load old configuration data.set_bootstrap_limit( bootstrap_limit=bootstrap_limit) config.load_configuration( load_limit=load_limit) # Remove old files config.set_rm_limit( rm_limit=rm_limit) config.rm_old_files() # Run the server server.run( ( host, port))
df_movie = fill_nan(df_movie)
df_movie = df_movie.drop(columns="imdb_score")
print(df_movie["director_name"].head())
col_mask = print(df_movie.isna().any(axis=0))
print(col_mask)
# return the processed dataset.
return df_movie
if __name__ == "__main__":
# df_movie, df_standard = data_prepocessing()
# df_knn = df_movie
# df_knn = df_knn.reset_index()
# df_knn["class"] = df_knn.apply(classify, axis=1)
# classes = list(df_knn["class"])
# amazing = classes==['AMAZING']
# print(amazing)
# df_knn = df_knn.drop(columns="imdbRating")
df_movie = load_metadata_dataset()
#run_knn(df_movie)
#run_logistic_regression(df_movie)
classifier=run_random_forest(df_movie)
run(classifier)
action='store',
dest='port',
type=int,
default=8000,
help='Server port')
parser.add_argument('-l',
action='store',
dest='log_number',
type=int,
default=0,
help='Log level 0-2')
args = parser.parse_args()
arg_address = args.address
arg_port = args.port
arg_log_number = args.log_number
return arg_address, arg_port, arg_log_number
def get_log_level(number):
log_level_dict = {0: logging.DEBUG, 1: logging.INFO, 2: logging.ERROR}
return log_level_dict.get(number, logging.INFO)
if __name__ == '__main__':
srv_address, srv_port, log_number = arg_parser()
log_level = get_log_level(log_number)
root_logger = logging.getLogger()
set_logger(srv_address, srv_port, root_logger, log_level)
root_logger.info('Starting server')
server.run(srv_address, srv_port)
import server server.run()
import server
import sys
""" Main """
if __name__ == "__main__":
if len(sys.argv) == 1:
server.run("localhost", 8000)
else:
server.run(sys.argv[1], sys.argv[2])
#!/usr/bin/env python3
import server
import sys
if __name__ == "__main__":
if len(sys.argv) < 2:
server.run()
else:
server.run(sys.argv[1])
import os
from server import app as application, run
if __name__ == '__main__':
ip = os.environ.get('OPENSHIFT_PYTHON_IP', '0.0.0.0')
port = int(os.environ.get('OPENSHIFT_PYTHON_PORT', 8051))
# Para detalhae melhor os Logs no OpenShift
application.config['PROPAGATE_EXCEPTIONS'] = True
run(ip, port)
def test_running_server(self):
server.run()
pass
def test_without_env_set(self):
with self.assertLogs('server', level='ERROR') as log:
with self.assertRaises(SystemExit):
runpy.run_module(run())
self.assertIn('ERROR:server:Missing environment variables!', log.output)
def test_connection():
server.run()
#!/usr/bin/env python3
from flask import request as frequest
from server import create, run
import sys
import utils
from hdfslib import do_hdfs_upload
import os
app = create(__name__)
hdfs_url = os.environ.get("HDFS_URL", "http://*****:*****@app.route('/upload', methods=['PUT'])
def upload_hdfs():
print("filename = ", frequest.form['filename'])
print("tagname = ", frequest.form['tagname'])
return do_hdfs_upload(hdfs_url,
utils.keyhash(frequest.environ["peercert"]),
frequest.form["filename"], frequest.files["file"],
frequest.form["tagname"])
if __name__ == "__main__":
run(app, "0.0.0.0", 20000, ca_cert, cert, key)
def main():
server.run(StepMotor4.open, StepMotor4.close)
from Template import Template
@get('/hello')
def say(self, query, *args):
hello = Hello()
name = query.get('name')
if name is None:
return hello.say()
return hello.say(', '.join(name))
@get('/hello/:name')
def hello(self, query, *args):
return Template.render('hello.tpl', {"name": args[0]})
@get('/greeting/:name')
def greeting(self, query, *args):
hello = Hello()
return hello.say(args[0])
@post('/comments')
def comment(self, data, *args):
print data
return ''
run(host='', port=8888)
from server import handler, run, post
from server import RequestHandler
@handler("index")
def printL(req):
with open('index.html', 'r') as myfile:
data = myfile.read().replace('\n', '')
return 200, {"Content-type": "text/html"}, data
@handler("af", "POST")
def answerpost(req):
data1 = str(post(req))
data1 = data1[1:]
data = "<head><title>Done</title>"
data = data + "</head>" + "<center><big style='font-size:24px'>" + data1 + "<br/><a href='index'>back</a></big></center></body>"
return 200, {"Content-type": "text/html"}, data
@handler("abc", "POST")
def answerpost1(req):
data = "<head><title>info</title></head>"
data = data + "<center><div style='background-color:aqua;'><big style='font-size:36px'>"
data = data + "this is an info page </br>if you're not in the space Program you'd better get away of here </div><br/>"
data = data + "<a href='index'>back</a></big> <br/></center>"
return 200, {"Content-type": "text/html"}, data
run()
#!/usr/bin/env python3
print("started")
import server
if __name__ == '__main__':
from sys import argv
if len(argv) == 2:
print(server.run(port=int(argv[1])))
else:
server.run()
print("finished main")
if name == "--seeds":
seeds = value.split(',')
if name == "--load-limit":
load_limit = value
if name == "--bootstrap":
load_limit = None
if name == "--bootstrap-limit":
bootstrap_limit = value
if name == "--rm-limit":
rm_limit = value
host, port = helpers.normalize_addr(bind)
if host is None:
die('Invalid binding address %s' % bind)
sync.init_cluster_state('%s:%s' % (host, port))
# FIXME avoid adding these seeds in cluster
for seed in seeds:
r = sync.cluster_state.add_instance(seed)
# Load old configuration
data.set_bootstrap_limit(bootstrap_limit=bootstrap_limit)
config.load_configuration(load_limit=load_limit)
# Remove old files
config.set_rm_limit(rm_limit=rm_limit)
config.rm_old_files()
# Run the server
server.run((host, port))
#!/usr/bin/env python
from boto.dynamodb2.table import Table
from server import run, Server
from handlers import RegistrationHandler, GetHandler
from store import get_client, store as _store, get as _get
import burnerconf
cache = get_client([burnerconf.CACHE_URL])
regy = Table('regy')
server = Server(
get=GetHandler(cache, regy),
register=RegistrationHandler(cache, regy),
)
run(server)
if args.update:
print('Update Brython scripts')
src_path = os.path.join(os.path.dirname(__file__), 'data')
for path in files:
shutil.copyfile(os.path.join(src_path, path), path)
if args.reset:
print('Reset brython_modules.js to standard distribution')
shutil.copyfile(os.path.join(os.getcwd(), 'brython_stdlib.js'),
os.path.join(os.getcwd(), 'brython_modules.js'))
if args.server:
import server
server.run(int(args.port))
if args.modules:
print('Create brython_modules.js with all the modules used by the application')
import list_modules
finder = list_modules.ModulesFinder()
finder.inspect()
finder.make_brython_modules()
if args.make_dist:
print('Make a Python distribution for the application')
import list_modules
finder = list_modules.ModulesFinder()
finder.inspect()
finder.make_brython_modules()
''' Created on 08-Mar-2016 @author: Rohan Shah ''' from server import app, run # Runs API WSGI SERVER # Use app variable as application when being used with uwsgi. run(app, host='localhost', port=8000, server='gevent')
import socket
import ftp_conn
import config
import server
import tests
config = config.Configuration()
if config.mode == 'server':
server.run(config)
elif config.mode == 'tests':
tests.run(config)
def main():
"""Perform the analysis."""
parser = argparse.ArgumentParser(description="Process some integers.")
parser.add_argument(
"pid", metavar="PID", type=int, nargs="?", help="the pid of the run to analyze, or omit to use the latest"
)
parser.add_argument("--ownTime", dest="sort", action="store_const", const="own", help="sort by own time")
parser.add_argument("--calls", dest="sort", action="store_const", const="calls", help="sort by call count")
parser.add_argument("--average", dest="sort", action="store_const", const="avg", help="sort by call count")
parser.add_argument("--total", dest="sort", action="store_const", const="total", help="sort by total time")
parser.add_argument("--max", dest="sort", action="store_const", const="max", help="sort by total time")
parser.add_argument("--class", dest="classRegex", help="regex for classes to include")
parser.add_argument("--message", dest="messageRegex", help="regex for messsages to include")
parser.add_argument("--threads", dest="action", action="store_const", const="threads", help="print thread list")
parser.add_argument("--thread", dest="thread", help="filter by thread")
parser.add_argument("--minTime", dest="minTime", help="minimum time in micros to include")
parser.add_argument("--maxTime", dest="maxTime", help="maximum time in micros to include")
parser.add_argument("--tree", dest="tree", help="print a call tree")
parser.add_argument("--list", dest="listMessage", help="print a list of the given message calls")
parser.add_argument("--server", dest="action", action="store_const", const="server", help="run server")
parser.add_argument("--files", dest="action", action="store_const", const="files", help="list profile files")
parser.add_argument("--clean", dest="action", action="store_const", const="clean", help="delete profile files")
args = parser.parse_args()
if args.action == "clean":
cleanDataFiles()
return
if args.action == "files":
listDataFiles()
return
data = getData(args.pid)
if args.action == "threads":
for threadName, thread in data.threads.iteritems():
print "%s - %d events" % (threadName, len(thread.events))
return
if args.action == "server":
from server import run
run(data)
return
if args.tree:
for node in data.threads[args.tree].tree:
printNode(node)
return
if args.listMessage:
return listMessages(data, args.listMessage)
rule = buildRule(args)
longestName, ownTime, count, avg, totalTime, maxTime = data.compute(rule)
sortBy = ownTime
if args.sort == "calls":
sortBy = count
elif args.sort == "avg":
sortBy = avg
elif args.sort == "total":
sortBy = totalTime
elif args.sort == "max":
sortBy = maxTime
mostTime = sorted(sortBy.items(), key=lambda x: x[1], reverse=True)[:100]
print "%s %s %s %s %s %s" % (
fit("message", longestName + 3),
fit("calls", 9),
fit("ownTime", 13),
fit("avgOwn", 11),
fit("maxOwn", 14),
fit("total", 15),
)
for name, _ in mostTime:
print "%s %s %s %s %s %s" % (
fit(name, longestName + 3),
fit("%d" % count[name], 9),
fit("%0.3fms" % (ownTime.get(name, 0) / 1000.0), 13),
fit("%0.4fms" % (avg.get(name, 0) / 1000.0), 11),
fit("%0.4fms" % (maxTime[name] / 1000.0), 14),
fit("%0.3fms" % (totalTime[name] / 1000.0), 15),
)
# -*- coding: utf-8 -*-
import sys
from server import app, run
if __name__ == "__main__":
try:
ipaddress = sys.argv[1]
port = int(sys.argv[2])
except:
ipaddress = '0.0.0.0'
port = 81313
run(app=app, server='flup', host=ipaddress, port=port)
Options:
-a, --address=<address> [default: 0.0.0.0]
-p, --port=<port> [default: 9000]
-l, --log=<logspec>
"""
import docopt
import sys
import pathlib
import iridescence
import logging
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
try:
from . import run
except ImportError:
from server import run
iridescence.quick_setup()
args = docopt.docopt(__doc__)
for logspec in args["--log"]:
module, level = logspec.split(":")
level = getattr(logging, level.upper())
logging.getLogger(module).setLevel(level)
run(args["--address"], int(args["--port"]))
def main(argv=None): # IGNORE:C0111
'''Command line options.'''
if argv is None:
argv = sys.argv
else:
sys.argv.extend(argv)
program_name = os.path.basename(sys.argv[0])
program_version = "v%s" % __version__
program_build_date = str(__updated__)
program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
program_license = '''SmartBus Remote Method Provider for IPSC CTI server.
Created by [email protected] on %s.
Copyright 2014 Hesong(GuangZhou) Info-Tech. All rights reserved.
USAGE
''' % (str(__date__))
program_runtime_message = '''
runtime:
executable: {}
version: {}
platform: {}
path:
{}
'''.format(sys.executable, sys.version, sys.platform, (os.linesep + ' ').join(sys.path))
globalvars.startuptxt = '''
{}
{}
version : {}
date : {}
update : {}
'''.format(program_version_message, program_runtime_message, __version__, __date__, __updated__)
try:
# Setup argument parser
parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
parser.add_argument('-V', '--version', action='version', version=program_version_message)
parser.add_argument("-v", "--verbose", action="store_true", help="output verbose logging text.")
parser.add_argument('-W', '--no-web-server', action='store_true', help="run the program without starting the web server.")
# Process arguments
args = parser.parse_args()
# set INTERRUPT signal handler
def handle_sigint(signum, frame):
print('SIGINT handled!')
server.stop()
signal.signal(signal.SIGINT, handle_sigint)
except KeyboardInterrupt:
### handle keyboard interrupt ###
return 0
except Exception as e:
if DEBUG or TESTRUN:
raise(e)
indent = len(program_name) * " "
sys.stderr.write(program_name + ": " + repr(e) + "\n")
sys.stderr.write(indent + " for help use --help" + "\n")
return 2
# startup server
print('startup server')
server.run(args)
print('program terminated')
return 0
img = self.client.service.get_file("NETWORK", 1, "test.xlsx")
assert img is not None, "File was not saved or retrieved correctly!"
result = self.client.service.remove_file("NETWORK", 1, "test.xlsx")
assert result == 'OK', "File was not deletd correctly!"
def test_download(self):
file_to_upload = open('test.xlsx','rb')
fileData = file_to_upload.read()
encodedData = base64.b64encode(fileData)
file_to_upload.close()
self.client.service.add_file("NETWORK", 1, "test.xlsx", encodedData)
img = self.client.service.get_file("NETWORK", 1, "test.xlsx")
assert img == encodedData, "File was not retrieved correctly!"
result = self.client.service.remove_file("NETWORK", 1, "test.xlsx")
assert result == 'OK', "File was not deletd correctly!"
def test_deletFile(self):
file_to_upload = open('test.xlsx','rb')
fileData = file_to_upload.read()
encodedData = base64.b64encode(fileData)
file_to_upload.close()
self.client.service.add_file("NETWORK", 1, "test.xlsx", encodedData)
result = self.client.service.remove_file("NETWORK", 1, "test.xlsx")
assert result == 'OK', "File was not deletd correctly!"
if __name__ == '__main__':
server.run()
import os
import pages
import server
server.run(int(os.environ.get("PORT", 0)))
def start():
server.run()
if args.update:
print('Update Brython scripts')
src_path = os.path.join(os.path.dirname(__file__), 'data')
for path in files:
shutil.copyfile(os.path.join(src_path, path), path)
if args.reset:
print('Reset brython_modules.js to standard distribution')
shutil.copyfile(os.path.join(os.getcwd(), 'brython_stdlib.js'),
os.path.join(os.getcwd(), 'brython_modules.js'))
if args.server:
import server
server.run(int(args.port))
if args.modules:
print('Create brython_modules.js with all the modules used by the application')
import list_modules
finder = list_modules.ModulesFinder()
finder.inspect()
finder.make_brython_modules()
if args.make_dist:
print('Make a Python distribution for the application')
import list_modules
finder = list_modules.ModulesFinder()
finder.inspect()
finder.make_brython_modules()
#!/usr/bin/env python3
import server
import sys
if __name__ == "__main__":
if len(sys.argv) > 1:
prefix = sys.argv[1]
else:
prefix = ''
server.run(prefix)
@route("GET", "/api/button")
def api_button(conn, request):
conn.write(b"HTTP/1.1 200 OK\r\n")
conn.write(b"Connection: close\r\n")
parameters = request["parameters"]
if "LED" in parameters:
led(0) if parameters["LED"] == "On" else led(1)
conn.write(b"Content-Type: text/html\r\n")
conn.write(json.dumps({"LED": parameters["LED"]}))
conn.write("\r\n")
return CONNECTION_CLOSE
@route("GET", "/api/toggle")
def api_toggle(conn, request):
global led
led.toggle()
conn.write(b"HTTP/1.1 200 OK\r\n")
conn.write(b"Connection: close\r\n\r\n")
return CONNECTION_CLOSE
@route("GET", "/api/stop")
def stop(conn, request):
conn.write(b"HTTP/1.1 200 OK\r\n")
conn.write(b"Connection: close\r\n\r\n")
raise Exception("Stop Server")
run(port=80)
def _get_next_move(self, state): d = server.get_move_from(self.cid[self.active], state) d.addCallbacks(self.move_received, self.err_received) def _winner(self, state, move): # Check verticals if state[move] == state[move-3] == state[move-6]: return state[move] # Check horizontals row = 3 * (move / 3) if state[row] == state[row+1] == state[row+2]: return state[row] # Check diagonals if state[0] == state[4] == state[8] or state[2] == state[4] == state[6]: return state[4] # Check draw if not 0 in state: return -1 # No winner return 0 ### Main External Call ### if __name__ == '__main__': server.run(TicTacToe)
# -*- coding: utf-8 -*-
import sys
from server import app,run
if __name__ == "__main__":
try:
ipaddress=sys.argv[1]
port=int(sys.argv[2])
except:
ipaddress = '0.0.0.0'
port = 81313
run(app=app,server='flup',host=ipaddress, port=port)
def nutThread():
server.run()
