def post(self): hash = self.request.body[:32] j = self.request.body[32:] m = md5(j + config.SENDCOMMAND_SECRET) if m.hexdigest() == hash: c = json.loads(j) serverinfo.ServerInfo.send_command(c['info'], json.dumps(c['command'])) if config.is_debug(): self.response.headers['Content-Type'] = 'text/plain' self.response.out.write('ok') else: if config.is_debug(): self.response.headers['Content-Type'] = 'text/plain' self.response.out.write('not ok')
def register_endpoints(app): """ Registers all the endpoints used by the frontend to deliver the index.html in all cases. :param app: the flask app """ @app.route("/", methods=["GET"]) def get_index(): """ Each call to the API, which doesn't start with `/api` will be covered by this function providing the index.html to the caller. The index.html will load the index.js in the browser, which will render the frontend. The frontend will then decide what view to render. The backend is not responsible for that. **IMPORTANT** This function needs to be updated whenever new frontend routes are added to the React router. You can provide multiple @app.route(..) lines for multiple frontend routes that all just return the frontend (because the frontend has it's own router which decides what page to render) :return: the index.html as file (basically delivering the whole frontend) """ return render_template("index.html") # prevent caching of the frontend during development if is_debug(): @app.after_request def add_header(r): """ Add headers to both force latest IE rendering engine or Chrome Frame, and also to cache the rendered page for 10 minutes. """ r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate" r.headers["Pragma"] = "no-cache" r.headers["Expires"] = "0" r.headers['Cache-Control'] = 'public, max-age=0' return r
def post(self): # Update server info j = self.request.body[32:] info = self.validate_request() if not info: if config.is_debug(): self.response.set_status(400, 'not valid') return # Update the model. key = models.serverinfomodel_key(info['name'], info['start_utc']) obj = models.ServerInfoModel.get(key) if not obj: obj = models.ServerInfoModel(key_name=key.name()) # Save the command command = obj.command obj.json = j obj.command = '' obj.expires_utc = info['expires_utc'] obj.put() # Update the cache now rather than just invalidating, so the latency # isn't on a client request self.gen_json() # Return command if there is one if command: # Use this mime type for simplicity, and so GAE doesn't strip # out Content-Length self.response.headers['Content-Type'] = 'binary/octet-stream' self.response.headers['Content-Length'] = len(command) self.response.out.write(command)
def main(): handlers = [ (config.ADDGAMESTATS_URL, addgamestats.AddGameStats), (config.AUTH_URL, auth.AuthUser), (config.LEADERBOARD_URL, leaderboard.Leaderboard), (config.AVATAR_URL, avatar.AvatarHandler), (config.STATS_URL, stats.Stats), (config.GAMES_URL, games.Games), (config.SEARCH_URL, search.Search), (config.ABOUT_URL, about.About), (config.GAMEDETAIL_URL, gamedetail.GameDetail), (config.MESSAGE_URL, message.Message), (config.CREATEACCOUNT_URL, createaccount.CreateAccount), (config.UPDATEACCOUNT_URL, updateaccount.UpdateAccount), (config.SERVERINFO_URL, serverinfo.ServerInfo), (config.SYNCERROR_URL, syncerror.SyncError), (config.ADMIN_URL, admin.Admin), (config.SENDCHAT_URL, sendchat.SendChat), (config.DRAIN_URL, drain.Drain), (config.SENDCOMMAND_URL, sendcommand.SendCommand), (config.BLOCKPLAYER_URL, blockplayer.BlockPlayer), (config.HIDEPLAYER_URL, hideplayer.HidePlayer), (config.RESETPLAYER_URL, resetplayer.ResetPlayer), (config.RATINGJOB_URL, ratingjob.RatingJob), (config.GETGAMES_URL, getgames.GetGames), (config.PLAYERDETAIL_URL, playerdetail.PlayerDetail), (config.ADJUSTSCORE_URL, adjustscore.AdjustScore), (config.ADMINLOG_URL, adminlog.AdminLog), ] application = webapp.WSGIApplication(handlers, debug=config.is_debug()) run_wsgi_app(application)
def main(): # initializing pygame pygame.init() pygame.mixer.init() pygame.font.init() # setting up the game window resolution = config.get_resolution() win = pygame.display.set_mode(resolution) pygame.display.set_caption("Tudo que entra, também sai") pygame.display.set_icon(load_image(images.TOILET_ICON)) clock = pygame.time.Clock() # scenes dictionary, to ease the access router = { START_SCENE: StartScene(win), GAME_SCENE: None, GAME_OVER_SCENE: GameOverScene(win), HOW_TO_PLAY_SCENE: HowToPlayScene(win), CREDITS_SCENE: CreditsScene(win) } # current scene being rendered current_scene = router[config.get(config.STARTING_SCENE) or START_SCENE] prev_command = None command = None while 1: events = pygame.event.get() for event in events: if event.type == pygame.QUIT: sys.exit() elif config.is_debug() and event.type == pygame.MOUSEBUTTONDOWN: print(pygame.mouse.get_pos()) prev_command = command # renders a scene and receives a command from it if prev_command is not None: command = current_scene.render( events=events, more_args=prev_command.get('more_args')) else: command = current_scene.render(events=events) # when the previous command is not the game scene, it means we're starting a new game scene starting_at_game_scene = prev_command is None and command[ 'goto'] == GAME_SCENE moving_to_game_scene = prev_command is not None and prev_command[ 'goto'] != GAME_SCENE and command['goto'] == GAME_SCENE if starting_at_game_scene or moving_to_game_scene: router[GAME_SCENE] = GameScene(win) # the command contains a goto action indicating the next scene to be rendered current_scene = router[command['goto']] pygame.display.update() clock.tick(40)
from sqlalchemy import create_engine, Column, Integer, String, DateTime, ForeignKey, Table from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship, sessionmaker from config import initialize_config, is_debug from os import environ initialize_config() Base = declarative_base() engine = create_engine('postgresql://{DBUSER}:{DBPASS}@{DBSERVER}:{DBPORT}/{DBNAME}'.format(**environ), echo=is_debug()) song_chord = Table('song_chord', Base.metadata, Column('song_id', Integer, ForeignKey('song.id'), index=True), Column('chord_id', Integer, ForeignKey('chord.id'), index=True) ) class Song(Base): __tablename__ = 'song' id = Column(Integer(), primary_key=True, nullable=False, autoincrement=True) artist = Column(String(length=200)) name = Column(String(length=200), nullable=False) url = Column(String(length=200), nullable=False, unique=True, index=True) rating = Column(Integer()) created_date = Column(DateTime(), nullable=False, index=True) chords = relationship('Chord', secondary=song_chord, backref='songs', lazy='joined') def __str__(self): return '"{0}" by {1}'.format(self.name, self.artist)
_, line = line.split('\t', 1) except ValueError: continue segs = [s.strip() for s in line.split('\05')] if len(segs) < NUM or not segs[ADSL]: continue info.adsl = segs[ADSL] # DOMAIN 字段实际为host info.host = segs[HOST] info.raw_url = segs[URL] # 对URL进行urllib2.decode解码,将其中的%转码过的信息还原为原始字符串 info.url = trans_str(info.raw_url) info.url = utility.spider_url_to_dpi_url(info.url) info.domain = utility.host_to_domain(info.host) if config.is_debug(): print u"test" + u",".join( [info.adsl, info.url, info.host, info.domain]) label_id = set() update_label_id(info.url, label_id) update_label_id(info.refer, label_id) if len(label_id) > 0: try: print u"\t".join([info.adsl, u",".join(label_id)]) except UnicodeEncodeError: pass
logout_user, login_required) from flask_oauthlib.client import OAuth from utils.formutils import write_errors_to_flash from utils.templatehelpers import url_for_lang, lang_name, get_translation from utils.data import get_measurement_data from utils.impersonation import ImpersonationContext def get_send_file_max_age(self, name): return 31449600 Flask.get_send_file_max_age = get_send_file_max_age app = Flask(__name__) app.config['COMPRESS_DEBUG'] = is_debug() app.config['ASSETS_DEBUG'] = is_debug() app.jinja_env.globals['now'] = datetime.utcnow() app.jinja_env.globals['periods'] = PERIODS app.jinja_env.globals['url_for_lang'] = url_for_lang app.jinja_env.globals['lang_name'] = lang_name app.jinja_env.globals['get_translation'] = get_translation app.jinja_env.globals['LANGUAGES'] = LANGUAGES app.jinja_env.globals['ADMIN_USER'] = environ['ADMIN_USER'] app.jinja_env.globals['impersonation_context'] = ImpersonationContext() app.secret_key = environ['APPSECRET'] login_manager = LoginManager(app) login_manager.login_view = 'login' oauth = OAuth()
# -*- coding: utf-8 -*- import argparse import locale import tornado.ioloop import tornado.web import config from config import AppConfig import routes # date of release; run fab timestamp to set it __date__ = "2012-03-01 19:02:03+0000" __version__ = "1" if __name__ == '__main__': args_parser = argparse.ArgumentParser() args_parser.add_argument("-p", "--port", type=int) clargs = vars(args_parser.parse_args()) port = clargs["port"] if port is None: port = 8000 locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') application = tornado.web.Application(routes.all, cookie_secret=AppConfig.default().cookie_secret, debug=config.is_debug()) application.listen(port, xheaders=True) tornado.ioloop.IOLoop.instance().start()
ContentStore(mongo_url=mongo_url, mongo_db=mongo_db, collection_name="content"), } # create flask app app = Flask(__name__) # register endpoints static_api.register_endpoints(app) # register endpoints for authentication and user management register_user_endpoints(app, stores["user"], stores["user_tokens"]) # register endpoints for data management and retrieval register_data_endpoints( app, stores["data"], { "manage_permission": "data", # permission required to manage content "login_check_function": check_login_state, # this function ties the authentication module into this one }) # register endpoints for content management register_content_endpoints( app, stores["content"], { "manage_permission": "content", "login_check_function": check_login_state, }) # start flask app app.run(host='0.0.0.0', port=get_port(), debug=is_debug())
def debug(message): """ Only logs message if its debug mode """ if config.is_debug(): print(message)
from models.Subscription import Item from config import database_name, user_collection from billing.stripe import stripe from starlette.responses import RedirectResponse from config import MAIN_URL from auth.oauth2 import oauth2_scheme, verify_token from errors.auth import credentials_exception from errors.billing import payment_system_exception from models.User import UserInfo from dependencies import find_user from core.Plan import get_tier from config import is_debug, COUPON_ID router = APIRouter(prefix="/billing", tags=["billing-route"], include_in_schema=is_debug()) class BillingURL: success = MAIN_URL + "/#success" plans_page = MAIN_URL + "/plans" sign_up_page = MAIN_URL + "/join" @router.post( "/session", ) async def billing_session( plan: Item, token: UserInfo = Depends(oauth2_scheme), db: AsyncIOMotorClient = Depends(get_database), ):
from binance.enums import SIDE_BUY, SIDE_SELL, ORDER_TYPE_MARKET from binance.exceptions import BinanceAPIException, BinanceOrderException import binance_client import binance_sockets import config import tickers import log # CONFIGS BINANCE_MAX_PRECISION = config.get('binance_max_precision') MARKETS = config.get('markets') ORDER_VALUE = config.get('order_value') MIN_SPREAD = config.get('min_spread') TEST_MODE = config.is_test() DEBUG_MODE = config.is_debug() # CONSTS LIST_LIMIT = 5 FEE = 0.05 # Tracking variables start_time = datetime.now() arbitrages_count = 0 reverse_arbitrages_count = 0 check_count = 0 # General exchange info exchanges = [] SYMBOLS = [
@app.route('/chord_filter', methods=['GET']) def chord_filter(): q = request.args.get('q') r = [c for c in _get_all_chords() if c['name'].lower().startswith(q.lower())] if q else [] return jsonify(results=r) @app.route('/search', methods=['GET']) def search(): results, chords, total_count, elapsed = _search(request.args.get('q'), list(map(int, request.args.get('crd', '').split(','))) if request.args.get('crd', '') else [], _get_current_page(), request.args.get('s')) page_data = { 'query': request.args.get('q'), 'chord_names': ', '.join([c['name'] for c in chords]) if chords else '', 'selected_chords': chords, 'results': results, 'total_count': total_count, 'elapsed': elapsed, 'pagination': Pagination(_get_current_page(), PAGE_SIZE, total_count), 'stats': _get_stats() } return render_template('search_results.html', **page_data) if __name__ == '__main__': app.run(debug=is_debug(), use_reloader=False)
from fastapi import APIRouter, Depends, status from fastapi.responses import JSONResponse from models.User import UserInfo, UpdateUser from errors.auth import credentials_exception from db.mongodb import AsyncIOMotorClient, get_database from config import database_name, user_collection, is_debug from auth.oauth2 import ( oauth2_scheme, verify_token, ) router = APIRouter(prefix="/user", include_in_schema=is_debug()) @router.get("/", tags=["user"]) async def get_current_user( token: UserInfo = Depends(oauth2_scheme), db: AsyncIOMotorClient = Depends(get_database), ): if token: id = verify_token(token) else: raise credentials_exception if (user := await db[database_name] [user_collection].find_one({"_id": id}, { "_id": False, "hashed_password": False })) is not None: return user raise credentials_exception
allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.add_event_handler("startup", connect_to_mongo) app.add_event_handler("shutdown", close_mongo_connection) app.include_router(users.router, prefix=API_V1_STR) app.include_router(matches.router, prefix=API_V1_STR) app.include_router(auth.router, prefix=API_V1_STR) app.include_router(billing.router) app.include_router(webhooks.webhooks, prefix=API_V1_STR) app.include_router(model_stats.router, prefix=API_V1_STR) app.include_router(plans.router) if __name__ == "__main__": print("DEBUG", is_debug()) print("Database URI ", MONGO_URI) print("Database: ", MONGO_DB) print("ALLOWED_HOSTS: ", ALLOWED_HOSTS) uvicorn.run( "main:app", host="0.0.0.0", port=8000, log_level="info", reload=is_debug(), )