async def main(self): print(f'Connecting to websocket server: {ConfigManager.get("websocket_uri").format("xxxxx")}') self.server = ServerAdapterFactory.get_adapter( ConfigManager.get('server_adapter'), ConfigManager.get('websocket_uri').format(ConfigManager.get('auth_token')) ) await self.saved_data.init_db() await self.server.exec_with_context(self.run)
def test_fron_stream(self): stream = open("../config/test_config/chat.yaml", "r") cfg = ConfigManager(stream) self.assertIsNotNone(cfg.config) self.assertIsInstance(cfg.config, dict) self.assertIsNotNone(cfg.get("meta")) self.assertEqual(cfg.get("meta"), cfg["meta"]) stream.close()
async def store_match(self, match: GameInstance, score_white: int, score_black: int): if match.color == 'white': white_username = ConfigManager.get('username') or '' black_username = match.opponent else: black_username = ConfigManager.get('username') or '' white_username = match.opponent if white_username == black_username: winner = 'self-challenge' elif score_white > score_black: winner = 'white' elif score_black > score_white: winner = 'black' else: winner = 'tie' match_params = ( self.next_match_id, match.board_id, match.start, match.end, white_username, black_username, score_white, score_black, winner, ) match_id = self.next_match_id cursor = await self.conn.execute(self.match_check_query, (match.board_id,)) if await cursor.fetchone(): print(f'Duplicate match: {match.board_id}') return cursor = await self.conn.execute(self.match_insert_query, match_params) print(f'Saved match: {match.board_id} as {match_id}') self.next_match_id = cursor.lastrowid if match.save_history: await self.store_moves(match_id, match.move_history) else: print(f'Moves not available for match {match_id}')
async def exec_with_context(self, callback: callable): while True: try: async with websockets.connect(self.uri) as self.websocket: logger.info('Connected to websocket server') await callback() except Exception as e: print(f'Error: {e}') logger.error(f'Error: {e}') print('Reconnecting...') logger.info('Reconnecting...') if ConfigManager.get('debug'): raise
def start(): # Logging logging.basicConfig(filename="FA_bot.log", level=logging.DEBUG, format="%(asctime)-15s %(message)s") logging.info("FAbot starting up") # Configuration file logging.info("Reading configuration") config = ConfigManager("config.ini") client_email = config.get("email") client_pass = config.get("password") event_manager.announcement_channels = config.get_json("announcement_channels", default=[]) # TODO: probably event manager should take channels from client instead? main_client.channel_whitelist = config.get_json("channel_whitelist", default=[]) main_client.announcement_channels = config.get_json("announcement_channels", default=[]) main_client.welcome_pm = config.get("welcome_pm") main_client.join_announcement = config.get("join_announcement") main_client.leave_announcement = config.get("leave_announcement") # Game servers game_servers.game_servers['arma'] = game_servers.ArmaServer( ip=config.get("arma_server_ip"), port=int(config.get("arma_server_port")) ) game_servers.game_servers['insurgency'] = game_servers.InsurgencyServer( ip=config.get("insurgency_server_ip"), port=int(config.get("insurgency_server_port")) ) # Discord client logging.info("Logging into Discord") main_client.login(client_email, client_pass) if not main_client.is_logged_in: logging.critical("Logging into Discord failed") print('Logging in to Discord failed') exit(1) logging.info("Entering main message event loop") main_client.run()
def __init__( self, board_id: str, opponent: str, color: str, board: str, strategy: AIStrategy, ): self.player = ConfigManager.get('username') or '' self.board_id = board_id self.opponent = opponent self.color = color self.strategy = strategy self.board = Board(board) self.start = datetime.now() self.save_history = True self.move_history = []
async def play(self, turn_token: str, server: BaseServerAdapter, color: str, moves_left: int, board: str = None): if board and self.player != self.opponent: opponent_color = 'white' if color != 'white' else 'black' try: opponent_move = self.board.update(board, opponent_color) if opponent_move.is_valid(): opponent_move.execute(self.board) except BoardDesyncException: if self.save_history: print('Disabling move history for this game') self.save_history = False self.move_history = [] else: if self.save_history: self.move_history.append(opponent_move) move = self.strategy.play(self.board, color, moves_left) move.execute(self.board) if self.save_history: self.move_history.append(move) x1, y1, x2, y2 = move.to_coords() await server.send( 'move', { 'board_id': self.board_id, 'turn_token': turn_token, 'from_row': y1, 'from_col': x1, 'to_row': y2, 'to_col': x2, }) if ConfigManager.get('print_match'): print(f'{color} vs {self.opponent}:') for row in self.board.current: print(row) print()
def create_tables(): config = ConfigManager() conn = sqlite3.connect(config.get("application", "dbname")) cursor = conn.cursor() cursor.execute("DROP TABLE IF EXISTS config") cursor.execute("DROP TABLE IF EXISTS methods") cursor.execute("DROP TABLE IF EXISTS methods_config") cursor.execute("DROP TABLE IF EXISTS models") conn.commit() cursor.execute( """CREATE TABLE config ( id integer NOT NULL, host character varying NOT NULL, user character varying NOT NULL, password character varying NOT NULL, port integer NOT NULL, database character varying NOT NULL, PRIMARY KEY (id) )""" ) cursor.execute( """CREATE TABLE models ( id integer NOT NULL, name character varying NOT NULL, class_name character varying, use boolean DEFAULT 0, PRIMARY KEY (id) )""" ) cursor.execute( """CREATE TABLE methods_config ( id integer NOT NULL, model_id integer NOT NULL, method_name character varying NOT NULL, async boolean DEFAULT 0, use boolean DEFAULT 1, UNIQUE(method_name, model_id), PRIMARY KEY (id), FOREIGN KEY(model_id) REFERENCES models(id) )""" ) cursor.execute( """CREATE TABLE methods ( id integer NOT NULL, model_id integer NOT NULL, method_name character varying NOT NULL, field_name character varying NOT NULL, use boolean DEFAULT 0, PRIMARY KEY (id), UNIQUE(method_name, field_name, model_id), FOREIGN KEY(model_id) REFERENCES models(id) )""" ) conn.commit() insert_db_tables()
from config_manager import ConfigManager ############################ ## HTTP POSTS ############################ import httplib from xml.dom import minidom def getText(nodelist): rc = [] for node in nodelist: if node.nodeType == node.TEXT_NODE: rc.append(node.data) return ''.join(rc) http_host = ConfigManager.get("app", "callback_host"); http_site = ConfigManager.get("app", "callback_site"); connection = httplib.HTTPConnection(http_host) connection.request("GET", "/" + http_site) response = connection.getresponse() if response.status == 200: data = response.read() dom = minidom.parseString(data) elements = dom.getElementsByTagName("href") if len(elements) > 0: print getText(elements[0].childNodes) else: print "ErrorCode: %d", response.status connection.close()
if os.path.exists(file): fp = open(file, "r") content = fp.read() fp.close() return content def writeFile(file, content): fp = open(file, "w") fp.write(content) fp.close() config_manager = ConfigManager() config = config_manager.get() #Run all languages to group all the words try: for language in config['languages']: words = [] try: if not (config['wake_word'] in words): words.append(config['wake_word']) except KeyError: print('Wake word required') sys.exit(1) pass
WSGI_APPLICATION = 'vilogged.wsgi.application' # Database # https://docs.djangoproject.com/en/1.8/ref/settings/#databases DATABASES = { 'default': {} } DATABASES['default']['NAME'] = DB_CONFIG['name'] DATABASES['default']['ENGINE'] = DB_CONFIG['engine'] DATABASES['default']['HOST'] = DB_CONFIG['host'] DATABASES['default']['USER'] = DB_CONFIG['user'] DATABASES['default']['PASSWORD'] = DB_CONFIG['password'] if DB_CONFIG.get('port'): DATABASES['default']['PORT'] = DB_CONFIG['port'] if DB_CONFIG.get('options'): DATABASES['default']['OPTIONS'] = DB_CONFIG['options'] # Internationalization # https://docs.djangoproject.com/en/1.8/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'Africa/Lagos' #USE_I18N = True #USE_L10N = True
from flask_jwt import JWT from security import authenticate, identity as identity_function from user import UserRegister from app_logging import AppLogger from config_manager import ConfigManager from connection.db import DbInit from item import Item, ItemList from datetime import timedelta import os DEFAULT_PORT = 5050 logger = AppLogger.get_logger(__name__) app = Flask(__name__) app.secret_key = os.environ.get("JWT_SECRET", ConfigManager.get("jwt_secret", "jose")) api = Api(app) app.config["JWT_EXPIRATION_DELTA"] = timedelta( seconds=3600) # 1 hour expiration time # config JWT auth key name to be 'email' instead of default 'username' app.config["JWT_AUTH_USERNAME_KEY"] = "email" jwt = JWT(app, authenticate, identity_function) # new endpont '/auth' # Requires Authorization header # JWT <token> @jwt.auth_response_handler def customized_response_handler(access_token, identity):
async def run(self): if ConfigManager.get('interface'): asyncio.create_task(self.cli_listener()) while True: try: response = await self.server.recv() if response['event'] == 'update_user_list': if self.user_list != response['data']['users_list']: self.user_list = response['data']['users_list'] print(f'Online users: {self.user_list}') elif response['event'] == 'gameover': game_instance = self.game_list.pop(response['data']['board_id'], None) white_score = int(response['data']['white_score']) black_score = int(response['data']['black_score']) if game_instance: color = game_instance.color opponent = game_instance.opponent game_instance.end = datetime.now() asyncio.create_task(self.saved_data.store_match(game_instance, white_score, black_score)) else: if response['data']['white_username'] == ConfigManager.get('username') or '': color = 'white' opponent = response['data']['black_username'] else: color = 'black' opponent = response['data']['white_username'] print(f'Game results for board: {response["data"]["board_id"]}') print(f'Opponent: {opponent}') if response['data']['white_username'] == response['data']['black_username']: print(f'Self-challenge: w -> {white_score} | b -> {black_score}') else: if white_score > black_score: if color == 'white': print(f'Victory as white: {white_score} to {black_score} points') else: print(f'Defeat as black: {black_score} to {white_score} points') elif black_score > white_score: if color == 'black': print(f'Victory as black: {black_score} to {white_score} points') else: print(f'Defeat as white: {white_score} to {black_score} points') else: print(f'Tie: {white_score} points') elif response['event'] == 'ask_challenge': if selfchallenge := response['data']['username'] == ConfigManager.get('username'): print('Self-challenge requested') else: print(f'Challenger: {response["data"]["username"]}') if (ConfigManager.get('accept_challenges') or selfchallenge)\ and len(self.game_list) < (ConfigManager.get('max_games') or 1): game_count = 0 for game in self.game_list.values(): if game.opponent == response["data"]["username"]: game_count += 1 if not selfchallenge or game_count <= (ConfigManager.get('max_games_per_user') or 1): await self.server.send( action='accept_challenge', data={'board_id': response['data']['board_id']} ) print(f'Challenge accepted:\n' f'Challenger: {response["data"]["username"]}\n' f'Board ID: {response["data"]["board_id"]}') else: print(f'Challenge rejected:\n' f'Challenger: {response["data"]["username"]}\n' f'Board ID: {response["data"]["board_id"]}') elif response['event'] == 'your_turn': if game_instance := self.game_list.get(response['data']['board_id']): asyncio.create_task(game_instance.play( turn_token=response['data']['turn_token'], server=self.server, board=response['data']['board'], color=response['data']['actual_turn'], moves_left=response['data']['move_left'], )) else: new_instance = GameInstance( board_id=response['data']['board_id'], opponent=response['data']['opponent_username'], color=response['data']['actual_turn'], board=response['data']['board'], strategy=AIStrategy(), ) self.game_list[response['data']['board_id']] = new_instance asyncio.create_task(new_instance.play( turn_token=response['data']['turn_token'], server=self.server, color=response['data']['actual_turn'], moves_left=response['data']['move_left'], )) print(f'New game - id: {new_instance.board_id} ' f'- color: {new_instance.color} ' f'- opponent: {new_instance.opponent}')
def __init__(self): self.db_file = ConfigManager.get( "database", Path(__file__).parent / DEFAULT_DB )
board=response['data']['board'], color=response['data']['actual_turn'], moves_left=response['data']['move_left'], )) else: new_instance = GameInstance( board_id=response['data']['board_id'], opponent=response['data']['opponent_username'], color=response['data']['actual_turn'], board=response['data']['board'], strategy=AIStrategy(), ) self.game_list[response['data']['board_id']] = new_instance asyncio.create_task(new_instance.play( turn_token=response['data']['turn_token'], server=self.server, color=response['data']['actual_turn'], moves_left=response['data']['move_left'], )) print(f'New game - id: {new_instance.board_id} ' f'- color: {new_instance.color} ' f'- opponent: {new_instance.opponent}') else: print(response) except self.server.exception: raise except Exception as e: print(f'Error: {e}') if ConfigManager.get('debug'): raise
format='[%(asctime)s] %(levelname)s (%(name)s): %(message)s') logger = logging.getLogger(__name__) # Override stored configuration with parameters if cmd_args.token: logger.info('Using token from command line') config['auth_token'] = cmd_args.token if cmd_args.interface: logger.info('Command line interface enabled') config['interface'] = True # Create configuration manager instance cfg_manager = ConfigManager(config) # Override log level with config if log_level := ConfigManager.get('log_level'): logger.level = log_level # Create game instance game = GameClient() # Start cli interface if config.get('interface'): ui = UI(game) logger.info('Starting UI thread') T = threading.Thread(target=ui.cli, daemon=True) T.start() # Call event loop logger.info('Starting game loop') try:
from security import authenticate, identity as identity_function from resources.user import UserRegister from app_logger import AppLogger from connection.db import DbInit from resources.item import Item, ItemList from datetime import timedelta from config_manager import ConfigManager import logging DEFAULT_PORT = 5050 logger = AppLogger.get_logger(__name__) ConfigManager.init() app = Flask(__name__) app.secret_key = os.environ.get( "JWT_SECRET", ConfigManager.get("jwt_secret", "jose") ) app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = Api(app) # app.config['JWT_AUTH_URL_RULE'] = '/login' app.config["JWT_EXPIRATION_DELTA"] = timedelta( seconds=3600 ) # 1 hour expiration time # app.logger.addHandler() for logr in (app.logger, logging.getLogger("werkzeug")): logr.addHandler(AppLogger.file_handler()) logr.addHandler(AppLogger.console_handler()) # config JWT auth key name to be 'email' instead of default 'username'
import yaml import os, sys currentdir = os.path.dirname(os.path.realpath(__file__)) parentdir = os.path.dirname(currentdir) sys.path.append(parentdir) # Import parent libs from app_logging import AppLogger from config_manager import ConfigManager from utils import AppUtils logger = AppLogger.get_logger(__name__) DEFAULT_DB = "resources/data.db" DATABASE = os.getcwd() + "/" + ConfigManager.get("database", DEFAULT_DB) class DbInit: @staticmethod def users(): with DbConnection() as db: logger.info("Initializing users") create_table = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, username text, password text)" # INTEGER PRIMARY KEY allows Auto incrementing id db.cursor.execute(create_table) @staticmethod def items(): with DbConnection() as db: logger.info("Initializing items") create_table = "CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name text, price real)" # INTEGER PRIMARY KEY allows Auto incrementing id
try: return manager.get_model(name).name, 200 except (IndexError): return "Model not found", 404 class Predict(Resource): def get(self, name): return "Post requests only" def post(self, name): data = request.json try: model = manager.get_model(name) return model.predict(data), 200 except IndexError: return "Model not found", 404 except ValueError: return "Inputshape incorrect", 500 else: return "An unkown error occurred", 500 api.add_resource(ModelList, '/', '/model') api.add_resource(Model, '/model/<string:name>') api.add_resource(Predict, '/model/<string:name>/predict') if __name__ == '__main__': app.run(debug=config.get("debug"), host=config.get("host"), port=config.get("port"))
def test_from_file(self): cfg = ConfigManager("../config/test_config/chat.yaml") self.assertIsNotNone(cfg.config) self.assertIsInstance(cfg.config, dict) self.assertIsNotNone(cfg.get("meta")) self.assertEqual(cfg.get("meta"), cfg["meta"])
class Server: def __init__(self, server_config_path, handler): """ Creates a new websocket server Args: server_config_path (str): path to server configuration """ self.config = ConfigManager(server_config_path) self.host = self.config["host"] self.port = self.config["port"] self.max_message_len = self.config.get("max_message_len", -1) self.running = False self.handler = handler @log(logger, logging.INFO) def start(self): """ Starts the server """ self.running = True start_server_async = websockets.serve(self.ws_handler_async, self.host, self.port) asyncio.get_event_loop().run_until_complete(start_server_async) asyncio.get_event_loop().run_forever() @log(logger, logging.INFO) async def ws_handler_async(self, websocket, path): """ Async websocket handler Args: websocket (Websocket): incoming connection path (str): incoming connection resource path """ # new connection await self.handler.handle_connection(websocket) try: # message in connection async for message in websocket: # If max_message_len is a valid value, slice message before handling if self.max_message_len >= 0: await self.handler.handle_message( websocket, message[:self.max_message_len]) else: await self.handler.handle_message(websocket, message) except websockets.exceptions.ConnectionClosed: # Log connection exception log_message( logger, f"Exception: ConnectionClosed in websocket {websocket}", logging.WARNING) finally: # websocket disconnects await self.handler.handle_disconnect(websocket) @log(logger, logging.CRITICAL) async def stop(self): """ Handles a server shutdown, waits for the handler to do whatever it needs to first """ await self.handler.handle_shutdown() asyncio.get_event_loop().stop() self.running = False log_message(logger, "SHUTDOWN COMPLETE", logging.CRITICAL) def __repr__(self): return f"<Server @{self.host}:{self.port}, running: {self.running}, handler: \n\t{str(self.handler)}>"
import os, sys currentdir = os.path.dirname(os.path.realpath(__file__)) parentdir = os.path.dirname(currentdir) sys.path.append(parentdir) # Import parent libs from app_logging import AppLogger from config_manager import ConfigManager import logging from user import User logger = AppLogger.get_logger(__name__, level=logging.INFO, log_file="test.log") if __name__ == "__main__": logger.info("info statement") logger.debug("debug statement") jwt_secret = ConfigManager.get("jwt_secret", "jose") logger.info(f"jwt_secret: {jwt_secret}") user = User.find_by_username("douglas") logger.info(f"user: {user}") currentdir = os.path.dirname(os.path.realpath(__file__)) parentdir = os.path.dirname(currentdir) logger.info(f"currentdir: {currentdir}, parentdir: {parentdir}")
def test_default(self): cfg = ConfigManager("../config/test_config/chat.yaml") self.assertEqual(cfg.get("BADKEY", "DEFAULT"), "DEFAULT") self.assertIsNone(cfg.get("BADKEY"))