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()
#!/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()