def test_simple(self):
left = Side("LEFT")
left2 = Side("LEFT")
right = Side("RIGHT")
self.assertEqual(left, "LEFT")
self.assertTrue(left.is_left())
self.assertFalse(left.is_right())
self.assertTrue(left.is_oppose(right))
self.assertTrue(left.is_oppose(left.fliped()))
self.assertFalse(left.is_oppose(left2))
self.assertTrue(left != right)
self.assertTrue(left == left2)
self.assertFalse(left2.fliped().is_left())
def breaks_advantage(insetscore, srv_side: Side):
"""breaks advantage for left: 0 - no adv. n>0 left leads n breaks. n<0 left trails.
>>> breaks_advantage((1, 1), srv_side=co.LEFT)
0
>>> breaks_advantage((0, 1), srv_side=co.LEFT)
0
>>> breaks_advantage((2, 0), srv_side=co.LEFT)
1
>>> breaks_advantage((1, 2), srv_side=co.RIGHT)
-1
>>> breaks_advantage((3, 0), srv_side=co.LEFT)
2
>>> breaks_advantage((1, 4), srv_side=co.RIGHT)
-2
>>> breaks_advantage((0, 6), srv_side=co.LEFT)
-3
"""
diff = insetscore[0] - insetscore[1]
if diff == 0:
return 0
if diff < 0:
return -breaks_advantage(co.reversed_tuple(insetscore), srv_side.fliped())
# only left may have advantage
if srv_side.is_left():
return (diff + 1) // 2
else:
return diff // 2
def tie_opener_side(num_ingame, srv_side: Side):
"""По текущему num_ingame (2-tuple) и текущему подающему вернем открывателя
>>> tie_opener_side((0, 0), srv_side=co.LEFT)
Side('LEFT')
>>> tie_opener_side((0, 0), srv_side=co.RIGHT)
Side('RIGHT')
>>> tie_opener_side((1, 0), srv_side=co.LEFT)
Side('RIGHT')
>>> tie_opener_side((1, 1), srv_side=co.LEFT)
Side('RIGHT')
>>> tie_opener_side((1, 1), srv_side=co.RIGHT)
Side('LEFT')
"""
return srv_side if tie_opener_serve_at(num_ingame) else srv_side.fliped()
def get_curset_opener_by_next(cursetnum, nextset_opener: Side, all_score):
"""
here all_score can be also Score object
>>> get_curset_opener_by_next(1, nextset_opener=co.LEFT, all_score=((6, 2), (6, 3)))
Side('LEFT')
>>> get_curset_opener_by_next(1, nextset_opener=co.LEFT, all_score=((6, 1), (6, 3)))
Side('RIGHT')
"""
curscr = all_score[cursetnum - 1]
curset_lastg_opener = nextset_opener.fliped()
curset_opener = (
curset_lastg_opener if sum(curscr) % 2 == 1 else curset_lastg_opener.fliped()
)
return curset_opener
def get_curset_opener(cursetnum, prevset_opener: Side, all_score):
"""
here all_score can be also Score object
>>> get_curset_opener(cursetnum=2, prevset_opener=co.LEFT, all_score=((6, 2), (6, 3)))
Side('LEFT')
>>> get_curset_opener(cursetnum=2, prevset_opener=co.LEFT, all_score=((6, 1), (6, 3)))
Side('RIGHT')
"""
assert 1 <= cursetnum <= 5
assert prevset_opener in (co.LEFT, co.RIGHT)
prevscr = all_score[cursetnum - 2]
prevset_lastg_opener = (
prevset_opener if sum(prevscr) % 2 == 1 else prevset_opener.fliped()
)
return prevset_lastg_opener.fliped()
def srv_side_at_begin(self, setnum: int):
if (
self.setnum is not None
and self.inset is not None
and self.is_left_srv is not None
):
if self.setnum == setnum:
return (
Side(self.is_left_srv)
if co.is_even(sum(self.inset))
else Side(not self.is_left_srv)
)
if (self.setnum + 1) == setnum and max(self.inset) >= 5:
prob_set_winner = Side(self.inset[0] > self.inset[1])
if self.is_left_srv is prob_set_winner.is_left():
return prob_set_winner.fliped()
return prob_set_winner
def match_has_min_proba(match, decset_open_side: Side):
def log_estimate():
if positive_prob > negative_prob:
max_prob = round(positive_prob, 3)
max_prob_plr = (match.second_player if decset_open_side.is_left()
else match.first_player)
back_beg_txt = "CLOSER"
else:
max_prob = round(negative_prob, 3)
max_prob_plr = (match.first_player if decset_open_side.is_left()
else match.second_player)
back_beg_txt = "OPENER"
log.info(f"clf {MODEL} try {match} \nopen_side:{decset_open_side} "
f"PROB: {max_prob} {back_beg_txt} PLR {max_prob_plr}")
predicts_db.write_predict(
match,
case_name='decided_00',
back_side=co.LEFT
if max_prob_plr is match.first_player else co.RIGHT,
proba=max_prob,
comments=back_beg_txt)
try:
variant = cco.Variant.find_match_variant(match, apply_variants)
if variant is None:
log.error("clf {} novarianted for: {}".format(
MODEL, match.tostring()))
return None, None
X_test = decset_match_features(match, decset_open_side, variant)
clf = variant.clf
proba = clf.predict_proba(X_test)
positive_prob = float(proba[0, 1])
negative_prob = float(proba[0, 0])
log_estimate()
if positive_prob >= variant.min_probas.pos:
return decset_open_side.fliped(), positive_prob
elif negative_prob >= variant.min_probas.neg:
return decset_open_side, negative_prob
except cco.FeatureError as err:
log.warn("clf {} prep err: {} {}".format(MODEL, err, match.tostring()))
return None, None
return None, None
def tie_serve_side_at(num_ingame, tie_open_side: Side) -> Side:
"""По текущему num_ingame (2-tuple) и открывателю вернем текущего подающего
>>> tie_serve_side_at((0, 0), tie_open_side=co.LEFT)
Side('LEFT')
>>> tie_serve_side_at((0, 1), tie_open_side=co.LEFT)
Side('RIGHT')
>>> tie_serve_side_at((1, 1), tie_open_side=co.LEFT)
Side('RIGHT')
>>> tie_serve_side_at((1, 1), tie_open_side=co.RIGHT)
Side('LEFT')
>>> tie_serve_side_at((1, 5), tie_open_side=co.LEFT)
Side('RIGHT')
>>> tie_serve_side_at((1, 6), tie_open_side=co.LEFT)
Side('LEFT')
"""
if tie_opener_serve_at(num_ingame):
return tie_open_side
else:
return tie_open_side.fliped()
def get_tie_open_side(num_ingame, serve_side: Side) -> Side:
"""По текущему num_ingame (2-tuple) и подающему вернем открывателя тайбрейка
>>> get_tie_open_side((0, 0), serve_side=co.LEFT)
Side('LEFT')
>>> get_tie_open_side((0, 1), serve_side=co.LEFT)
Side('RIGHT')
>>> get_tie_open_side((1, 1), serve_side=co.LEFT)
Side('RIGHT')
>>> get_tie_open_side((1, 1), serve_side=co.RIGHT)
Side('LEFT')
>>> get_tie_open_side((1, 5), serve_side=co.LEFT)
Side('RIGHT')
>>> get_tie_open_side((1, 5), serve_side=co.RIGHT)
Side('LEFT')
"""
summa = (num_ingame[0] + num_ingame[1]) % 4
if summa in (0, 3):
return serve_side
else:
return serve_side.fliped()
