def learn(env_id, algorithm, env_type, seed, log_path, **kwargs): """ Learn entry """ sub_folder = '{}_{}_{}'.format(env_id, algorithm, seed) log_path = os.path.join(log_path, sub_folder) logger = init_logger(log_path) set_global_seeds(seed) env, kwargs = build_env(env_id, algorithm, env_type, seed, log_path, **kwargs) algorithm = algorithm.lower() options = get_algorithm_parameters(env, env_type, algorithm, **kwargs) module = get_algorithm_module(algorithm, algorithm) s = '\n' + '-' * 60 + '\n' option_repr = ''.join( '{}{}: {}'.format(s, k, v.__repr__()) for k, v in options.items()) + s logger.info('Start training `{}` on `{}` with settings {}' .format(algorithm, env, option_repr)) try: getattr(module, 'learn')(logger, env=env, **options) except Exception as e: logger.critical('algorithm execute fail', exc_info=e)
import typing from datetime import datetime from common.logger import init_logger from common.model import Game, Player from rest_service.db.db_manage import Manage from rest_service.db.db_search import Search from rest_service.ranking.ranking import TrueSkillRanking from .valid_requests import AddNickRequest, ForgetNickRequest, AddGameRequest, GamesRequest, PlayerRequest, \ PlayersRequest, TopRequest, valid_request_from_dict logger = init_logger('RestRequestHandler') class RestRequestHandler: ranking = TrueSkillRanking def __init__(self, search=None, manage=None): self._search = search if search is not None else Search() self._manage = manage if manage is not None else Manage() async def get_home(self, args: typing.Dict): return f'/?{args}' async def post_nick(self, args: typing.Dict): logger.debug(f'post_nick {args}') request = valid_request_from_dict(AddNickRequest, args) if await self._search.load_player_by_nick(request.nick) is not None:
if timeout: t = Timer(timeout, kill, [process]) t.start() output, error = process.communicate() if timeout: process.wait() t.cancel() if process.returncode != 0: try: process.terminate() except OSError: pass # ignore if not ignore: logging.error( "Run command failed! (code:%d, erro:%s)\ncmd: [%s]\n%s" % (process.returncode, error, cmd, output)) return None return output # test if __name__ == "__main__": init_logger() outs = command("ping -c 1 8.8.8.8; sleep 6", timeout=1) print outs
# -*- coding: utf-8 -*- __author__ = 'wangjian' __time__ = '2020-06-03' from thirdparty.kafka.kafka_cluster import KafkaDao from thirdparty.process.adb_process import AdbMaster, AdbWorker import settings from thirdparty.process import generate_worker_id import json from common import logger logger.init_logger() def send_kafka_msg(msg): kafka_cluster = KafkaDao() kafka_cluster.send_message( settings.Conf.get('kafka_info', 'adb_cmd_event'), msg) def init_process(): master = AdbMaster() for i in range(settings.PROCESS_WORKER): worker_id = generate_worker_id() master.add_worker(AdbWorker(worker_id)) master.start() msg = { 'event_type': 'adb',
import json import re from collections import namedtuple from common.model import Player from common.logger import init_logger logger = init_logger('TelegramInteraction') MessageIds = namedtuple( 'MessageIds', [ 'user_id', # telegram user id 'inline_query_id', # can be None 'message_id', # can be None 'chat_id' # can be None ]) TelegramInMessage = namedtuple( 'TelegramInMessage', [ 'kind', # message, inline_query, callback_query 'command', # bot's command 'input', # text or contact 'ids', # MessageIds ]) TelegramOutMessage = namedtuple('TelegramOutMessage', ['method', 'body'])
def __arg_parser(): parser = ArgumentParser() parser.add_argument('-d', '--debug', action='store_true', default=False, help='Enable debug logging', dest='debug') parser.add_argument('-y', '--year', default=datetime.now().year, action='store', type=int, help='Current fiscal year of the report to be generated (valid integer in YYYY format). ' 'Default value is current fiscal year.', dest='year') parser.add_argument('-m', '--month', default=get_prev_fiscal_month(), action='store', type=str, help='Current month of the report to be generated (valid 3-character string in MMM format). ' 'Default value is current date previous month.', dest='month') parser.add_argument('-p', '--path', default=get_dir_path(TEMPLATES), action='store', type=str, help='Base directory of report templates', dest='templates_root') parser.add_argument('-e', '--exclusions', default=list(), action='store', type=list, help='List of measure IDs to be excluded from the report', dest='exclusions') parser.add_argument('-o', '--output', default=get_dir_path(OUTPUT), action='store', type=str, help='Report output directory', dest='out_dir') parser.add_argument('--orca', default=None, action='store', type=str, help='Path to orca executable file', dest='orca_path') return parser.parse_args() if __name__ == '__main__': args = __arg_parser() init_logger(args.debug) logging.info('PDF report generating tool') __main(args)
import xworkflows from common.logger import init_logger from .telegram_interaction import TelegramInteraction # used for parsing request into command with input # and for composing response telegram = TelegramInteraction() logger = init_logger('Bot') class AbstractSession(): state = None # A list of transitions and checks performed on an input without command # check returns tuple (index of transition, parsed args) # (source state, check, transitions) raw_input_transitions = () def __init__(self): # queue of responses self.responses = [] # creates message via telegram_interactions and puts to resposes def show_message(self, message=None, buttons=None, keyboard=False, processing_message=None,
import json import requests from common.model import player_from_dict, game_from_dict from common.logger import init_logger LISTS_DELIMITER = ';' logger = init_logger('BotRestClient') def do_request(url, params, method): try: logger.debug(f'request {method} {url} {params}') if method == 'GET': response = requests.get(url=url, params=params) if method == 'POST': response = requests.post(url=url, params=params) text = response.text status_code = response.status_code logger.debug(f'response {status_code} {text}') return status_code, json.loads(text) except Exception as e: logger.error(f'do_request {params} {method} error: {e}') return 400, {'error': f'{e}', 'error_type': 'client'} class RestClient(): def __init__(self, host, port): self.url = f'http://{host}:{port}/'
import functools import ssl import json import traceback import sys from aiohttp import web from common.logger import init_logger logger = init_logger('WebServer') OK_STATUS = 'OK' def respond_ok(response=None, text=None): logger.info(f'responding ok {response} {text}') if response is not None: text = json.dumps(response) return web.Response(content_type='text/json', text=text, status=200) def respond_error(response=None, text=None, code=406): logger.info(f'responding error {response} {text}') if response is not None: text = json.dumps(response) return web.Response(content_type='text/json', text=text, status=406) def respond_failure(response=None, text=None):
import asyncio import re import aiopg import psycopg2 from common.logger import init_logger from config.config import Config, initConfig logger = init_logger('DB') class DB: def __init__(self): self.dsn = f''' dbname={Config.rest_service.db_name} user={Config.rest_service.db_user} password={Config.rest_service.db_pw} host={Config.rest_service.db_host} port={Config.rest_service.db_port}''' logger.info(self.dsn) self.do_fetch_regexp = re.compile("^(SELECT|select)") self.conn_pool = None self.event_loop_id = None async def connect(self): self.conn_pool = await aiopg.create_pool(self.dsn) self.event_loop_id = id(asyncio.get_event_loop()) # script is list: [sql, list_of_params]
import json import xworkflows from common.model import Game, Player from common.logger import init_logger from .abstract_session import AbstractSession from .elements import Button logger = init_logger('BotSession') class SessionWorkflow(xworkflows.Workflow): # A list of state names, adding 's_' helps to ease reading states = (('init', 'Init state'), ('s_game_adding_player', 'Adding player in a game'), ('s_game_player_confirmed', 'Add player to game success'), ('s_game_new_player_phone', 'Adding phone for new player in a game'), ('s_game_set_won_score', 'Setting score of a winner'), ('s_game_set_lost_score', 'Setting score of a looser'), ('s_game_created', 'All fields of Game are filled'), ('s_nick_adding_player', 'Adding player to database'), ('s_nick_new_player_phone', 'Adding phone for new player'), ('s_players', 'Searching for player'), ('s_games', 'Searching for games')) # A list of transition definitions # Transition names are bot commands
import datetime from .player import Rating from common.logger import init_logger ratingSystem = 'trueskill' logger = init_logger('ModelGame') class Game: def __init__(self, game_id=0, nicks_won=None, nicks_lost=None, ratings=None, score_won=0, score_lost=0, date=None): self.id = game_id self.nicks_won = [] if nicks_won is None else nicks_won self.nicks_lost = [] if nicks_lost is None else nicks_lost self.ratings = {} if ratings is None else ratings self.score_won = score_won self.score_lost = score_lost self.date = date if self.date is None: self.date = datetime.datetime.now() def set_rating_before(self, nick: str, rating: Rating): if nick not in self.nicks_won and nick not in self.nicks_lost: logger.error( f'{nick} not in {self.nicks_won} and {self.nicks_lost}')
import logging from common import logger import telegram.ext as tg import handlers log = logger.init_logger('beachranks_console') updater = tg.Updater(token='447474042:AAHRrgLqblJTdeG3wvbMLn_tXVoHJdEtDxo') dispatcher = updater.dispatcher dispatcher.add_handler( tg.CommandHandler('add_player', handlers.add_player, pass_args=True)) dispatcher.add_handler( tg.CommandHandler('remove_player', handlers.remove_player, pass_args=True)) dispatcher.add_handler( tg.CommandHandler('player', handlers.player, pass_args=True)) dispatcher.add_handler( tg.CommandHandler('add_game', handlers.add_game, pass_args=True)) dispatcher.add_handler( tg.CommandHandler('games', handlers.games, pass_args=True)) dispatcher.add_handler(tg.CommandHandler('top', handlers.top, pass_args=True)) updater.start_polling()
import datetime from typing import List from common.logger import init_logger from common.model import Player, Rating, Game from .db import db logger = init_logger('DBSearch') ratingSystem = 'trueskill' class Search: @staticmethod def sql_find_all_games(player_id, vs_players, with_players): sql = 'select gp.game_id from beach_ranks.game_players gp' params = [player_id] if len(vs_players) > 0: sql = sql + ', beach_ranks.game_players vs' if len(with_players) > 0: sql = sql + ', beach_ranks.game_players w' sql = sql + ' where gp.player_id = %s' for i in vs_players: sql = sql + ' and gp.game_id = vs.game_id and gp.win != vs.win and vs.player_id = %s' params.append(i) for i in with_players: sql = sql + ' and gp.game_id = w.game_id and gp.win = w.win and w.player_id = %s' params.append(i) sql = sql + ' order by gp.game_id desc' return [sql, params]