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]
