def main():
try:
args = parse_command_line_args()
log.initialize(
co.logname(__file__, instance=args.instance),
file_level="debug",
console_level="info",
)
log.info(
"\n--------------------------------------------------------\nstarted"
)
dba.open_connect()
oncourt_players.initialize()
ratings.initialize("wta", rtg_names=("elo", ))
ratings.initialize("atp", rtg_names=("elo", ))
ratings.Rating.register_rtg_name("elo_alt")
app = Application(
wta_players=oncourt_players.players("wta"),
atp_players=oncourt_players.players("atp"),
)
app.master.title("Live")
app.mainloop()
log.info("sex: " + app.sex())
log.info("left_player: " + app.left_player_name())
log.info("right_player: " + app.right_player_name())
log.info("score: {}".format(app.score()))
log.info("level: {}".format(app.level()))
log.info("surface: {}".format(app.surface()))
dba.close_connect()
return 0
except Exception as err:
log.error("{0} [{1}]".format(err, err.__class__.__name__),
exc_info=True)
return 1
def do_stat():
log.initialize(
co.logname(__file__, instance=str(args.sex)),
file_level="debug",
console_level="info",
)
try:
log.info(__file__ + " started sex: " + str(args.sex))
start_datetime = datetime.datetime.now()
dba.open_connect()
ratings_std.initialize(sex=args.sex)
qual_seeds.initialize()
oncourt_players.initialize(yearsnum=18)
matchstat_process(sex=args.sex)
process(
(
WinFavoriteProcessor(args.sex),
TourAverageSetProcessor(args.sex),
),
args.sex
)
dba.close_connect()
log.info(
"{} finished within {}".format(
__file__, str(datetime.datetime.now() - start_datetime)
)
)
return 0
except Exception as err:
log.error("{0} [{1}]".format(err, err.__class__.__name__), exc_info=True)
return 1
def start(title, methods):
"""Start the application and handle exceptions."""
args = parse_args(title, methods)
log.initialize(args.pop('verbose'))
try:
function = args.pop('function')
log.debug('Starting %s with %s', function.__name__, args)
function(**args)
log.debug('Execution finish')
except AssertionError as error:
log.error(error)
except Exception as error:
log.exception(error)
def main(args, debug=False):
log.initialize()
logger = log.getLogger('cip')
if debug:
root_logger = log.logging.getLogger()
root_logger.setLevel('DEBUG')
for h in root_logger.handlers:
h.setLevel('DEBUG')
logger.warning(
'To display the verbose messages so the application performance maybe too bad.'
)
app = core.Application()
if len(args) < 2:
args.append('help:')
logger.debug('Loaded modules are following: {}'.format(
[m.getNamespace() for m in core.module.getModules()]))
logger.debug(args)
parser = arguments.ArgumentsParser()
parser.parse(args[1:])
tokens = parser.tokens()
procedures = list()
for token in tokens:
logger.debug(token)
proc = app.getProcedure(token.namespace(), token.operation())
if proc is None:
raise arguments.TokenError(token, 'A parsed token is not valid.')
if '_Prior' in proc.__dict__ and proc._Prior:
with proc() as p:
logger.debug('Prior:{}'.format(proc))
app.exec(p, token)
else:
procedures.append(proc)
for proc, token in zip(procedures, tokens):
with proc() as p:
logger.debug(p)
app.exec(p, token)
def createConnection(username, password):
"""Create connections to file servers using the given credentials."""
logConnection = auth.FileServerConnection(logServerAddress,
logServerPort,
"localhost",
logServerName,
username,
password)
dbConnection = auth.FileServerConnection(dbServerAddress,
dbServerPort,
"localhost",
dbServerName,
username,
password)
log.initialize(logConnection, logShare, logPath, username)
remoteLogger = logging.getLogger("remote")
remoteLogger.info("Logged in")
def do_stat():
log.initialize(
co.logname(__file__, instance=str(args.sex)),
file_level="debug",
console_level="info",
)
try:
msg = "sex: {} max_rtg: {} max_rtg_dif: {}".format(
args.sex, args.max_rating, args.max_rating_dif)
log.info(__file__ + " started {}".format(msg))
initialize(args.sex)
maker = StatMaker(args.sex)
maker.process_all()
log.info(__file__ + " done {}".format(ASPECT))
dba.close_connect()
log.info(__file__ + " finished sex: {}".format(args.sex))
return 0
except Exception as err:
log.error("{0} [{1}]".format(err, err.__class__.__name__),
exc_info=True)
return 1
def do_stat():
log.initialize(
co.logname(__file__, instance=str(args.sex)),
file_level="debug",
console_level="info",
)
try:
msg = "sex: {} min_size: {} max_size: {} max_rtg: {} max_rtg_dif: {}".format(
args.sex, args.min_size, args.max_size, args.max_rating,
args.max_rating_dif)
log.info(__file__ + " started {}".format(msg))
dba.open_connect()
oncourt_players.initialize(yearsnum=8)
min_date = tt.now_minus_history_days(history_days_personal(args.sex))
ratings_std.initialize(sex=args.sex,
min_date=min_date - datetime.timedelta(days=7))
initialize_results(
args.sex,
max_rating=args.max_rating,
max_rating_dif=args.max_rating_dif,
min_date=min_date,
)
maker = StatMaker(args.sex,
min_size=args.min_size,
max_size=args.max_size)
maker.process_all(aspect=RECOVERY_ASPECT)
log.info(__file__ + " done {}".format(RECOVERY_ASPECT))
maker.process_all(aspect=KEEP_ASPECT)
log.info(__file__ + " done {}".format(KEEP_ASPECT))
dba.close_connect()
log.info(__file__ + " finished sex: {}".format(args.sex))
return 0
except Exception as err:
log.error("{0} [{1}]".format(err, err.__class__.__name__),
exc_info=True)
return 1
import sys
from . import __version__, __description__
import cfg
import log
import scheduler
from jobs.domains_metadata_job import DomainsMetadataJob
from jobs.hypervisors_metadata_job import HypervisorsMetadataJob
from jobs.hypervisors_state_job import HypervisorsStateJob
from jobs.projects_metadata_job import ProjectsMetadataJob
from jobs.projects_quotas_job import ProjectsQuotasJob
from jobs.report_alive_job import ReportAliveJob
from jobs.vm_usage_job import VMUsageJob
log.initialize()
logger = log.get_logger(__name__)
DEFAULT_CFG_FILE = '/etc/caos/collector.conf.yaml'
_JOBS = {
'report_alive': ReportAliveJob,
'domains_metadata': DomainsMetadataJob,
'projects_metadata': ProjectsMetadataJob,
'hypervisors_metadata': HypervisorsMetadataJob,
'projects_quotas': ProjectsQuotasJob,
'vm_usage': VMUsageJob,
'hypervisors_state': HypervisorsStateJob,
}
for _job_name, _job_class in _JOBS.items():
def __init__(self, sex, left_player, right_player):
super(PageBuilderDecidedSetLGR, self).__init__()
self.set_data(sex, left_player, right_player)
def set_data(self, sex, left_player, right_player):
self.keys = ("decided", )
self.columns = [
make_player_columninfo(sex,
left_player.ident if left_player else None,
"left", 1),
make_generic_columninfo(sex, title="avg", number=2),
make_player_columninfo(
sex, right_player.ident if right_player else None, "right", 3),
]
def parse_command_line_args():
parser = argparse.ArgumentParser()
parser.add_argument("--sex", choices=["wta", "atp", "both"])
parser.add_argument("--stat", action="store_true")
return parser.parse_args()
if __name__ == "__main__":
log.initialize(co.logname(__file__), "info", "info")
args = parse_command_line_args()
if args.stat:
import make_stat
sys.exit(do_stat(sex=None if args.sex == "both" else args.sex))
rnd=Round("Second"),
date=datetime.date(2017, 2, 1),
)
h2hdir = HeadToHead(sex="atp", match=match,
completed_only=True).direct()
self.assertEqual(h2hdir, None)
@unittest.skip(
"actual only was 2019,10,18 and recent h2h match was 2019,9,26")
def test_recent_winner(self):
plr1 = Player(ident=6590, name="Cagla Buyukakcay", cou="TUR")
plr2 = Player(ident=8951, name="Veronica Cepede Royg", cou="PAR")
match = Match(first_player=plr1,
second_player=plr2,
score=None,
rnd=Round('Second'),
date=datetime.date(2019, 10, 18))
h2h = HeadToHead(sex='wta', match=match, completed_only=True)
recent_winner_id = h2h.recently_won_player_id()
self.assertEqual(recent_winner_id, plr1.ident)
if __name__ == '__main__':
import doctest
log.initialize(co.logname(__file__, test=True), "debug", None)
dba.open_connect()
doctest.testmod()
unittest.main()
dba.close_connect()
return 0
def parse_command_line_args():
parser = argparse.ArgumentParser()
parser.add_argument("--sex", choices=["wta", "atp", "both"])
parser.add_argument("--dayago1", type=int, choices=[1, 2, 3, 4, 5, 6, 7])
parser.add_argument("--dayago2", type=int, choices=[1, 2, 3, 4, 5, 6, 7])
parser.add_argument("--current_week", action="store_true")
parser.add_argument("--interactive", action="store_true")
return parser.parse_args()
if __name__ == "__main__":
args = parse_command_line_args()
if not args.dayago1 and not args.dayago2:
print("use --dayago1, --dayago2")
sys.exit(1)
else:
log.initialize(co.logname(__file__), file_level="info", console_level="info")
assert args.dayago1 <= args.dayago2, "daysago bad interval [{}, {}]".format(
args.dayago1, args.dayago2
)
dbdet_wta = open_db(sex="wta")
dbdet_atp = open_db(sex="atp")
sys.exit(
fetch_main(
args.dayago1, args.dayago2, sex=None if args.sex == "both" else args.sex
)
)
def log_init_debug():
log.initialize(
logname(__file__, test=True), file_level="debug", console_level="info"
)
yield # this is where the testing happens
def _actual_players_filename(sex):
return "{}/actual_players-{}.csv".format(cfg_dir.oncourt_players_dir(),
sex)
def _read_actual_players_id(sex):
with open(_actual_players_filename(sex)) as csvfile:
reader = csv.reader(csvfile, delimiter=",")
for row in reader:
return [int(i) for i in row]
def parse_command_line_args():
parser = argparse.ArgumentParser()
parser.add_argument("--make_actual_players", action="store_true")
parser.add_argument("--sex", choices=["wta", "atp"])
return parser.parse_args()
if __name__ == "__main__":
args = parse_command_line_args()
if args.make_actual_players:
log.initialize(co.logname(__file__), "debug", "debug")
if args.sex in ("wta", None):
write_actual_players(sex="wta")
log.info("wta actual players done")
if args.sex in ("atp", None):
write_actual_players(sex="atp")
log.info("atp actual players done")
import unittest
import log
import common as co
import dba
from decided_win_by_two_sets_stat import ENABLE_SOFT_LEVELS, read_scores_dict
class ReadFilesTest(unittest.TestCase):
def test_read_score_dict(self):
for soft_level in ENABLE_SOFT_LEVELS:
dct = read_scores_dict("wta", soft_level)
self.assertEqual(len(dct), 49)
if soft_level == "main":
sval = dct[((4, 6), (6, 0))]
self.assertTrue(0.6 < sval.value < 0.8)
self.assertTrue(120 < sval.size < 200)
if __name__ == '__main__':
log.initialize(co.logname(__file__, test=True), "info", "info")
unittest.main()
dba.close_connect()
return quals_from_tid[tour_id]
def _initialize_sex(sex):
quals_from_tid = __wta_quals_from_tid if sex == "wta" else __atp_quals_from_tid
sql = """select ID_T_S, ID_P_S
from Seed_{0}
where SEEDING Like '%q%' or SEEDING Like '%LL%'
order by ID_T_S;""".format(
sex
)
with closing(dba.get_connect().cursor()) as cursor:
for (tour_id, player_id) in cursor.execute(sql):
quals_from_tid[tour_id].append(player_id)
if __name__ == "__main__":
import log
log.initialize(
co.logname(__file__, test=True), file_level="debug", console_level="info"
)
dba.open_connect()
initialize()
print("wta len: %d" % len(__wta_quals_from_tid))
print("atp len: %d" % len(__atp_quals_from_tid))
dba.close_connect()
random_state=random_state,
)
hyperopt_search(
variant,
data,
max_evals=100,
mix_algo_ratio=clf_hp.MixAlgoRatio(tpe=0.50,
anneal=0.50,
rand=0.00),
random_state=random_state,
)
args = parse_command_line_args()
log.initialize(
co.logname(__file__, instance=args.log_instance),
file_level="info",
console_level="info",
)
co.log_command_line_args()
random_args = co.RandomArguments(args, default_seed=random_seed)
if args.variant:
if args.sex:
in_variant = cco.Variant.find_variant_by(
variants=train_variants,
predicate=lambda v: v.name == args.variant and v.sex == args.
sex,
)
else:
in_variant = cco.Variant.find_variant_by(
variants=train_variants,
predicate=lambda v: v.name == args.variant)
