def start(li, user_profile, engine_factory, config):
challenge_config = config["challenge"]
max_games = challenge_config.get("concurrency", 1)
logger.info("You're now connected to {} and awaiting challenges.".format(config["url"]))
manager = multiprocessing.Manager()
challenge_queue = manager.list()
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream, args=[control_queue, li])
control_stream.start()
busy_processes = 0
queued_processes = 0
with logging_pool.LoggingPool(max_games + 1) as pool:
while not terminated:
event = control_queue.get()
if event["type"] == "terminated":
break
elif event["type"] == "local_game_done":
busy_processes -= 1
logger.info("+++ Process Free. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(challenge_config):
challenge_queue.append(chlng)
if (challenge_config.get("sort_by", "best") == "best"):
list_c = list(challenge_queue)
list_c.sort(key=lambda c: -c.score())
challenge_queue = list_c
else:
try:
li.decline_challenge(chlng.id)
logger.info(" Decline {}".format(chlng))
except:
pass
elif event["type"] == "gameStart":
if queued_processes <= 0:
logger.debug("Something went wrong. Game is starting and we don't have a queued process")
else:
queued_processes -= 1
busy_processes += 1
logger.info("--- Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
game_id = event["game"]["id"]
pool.apply_async(play_game, [li, game_id, control_queue, engine_factory, user_profile, config, challenge_queue])
while ((queued_processes + busy_processes) < max_games and challenge_queue): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
logger.info(" Accept {}".format(chlng))
queued_processes += 1
li.accept_challenge(chlng.id)
logger.info("--- Process Queue. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
except (HTTPError, ReadTimeout) as exception:
if isinstance(exception, HTTPError) and exception.response.status_code == 404: # ignore missing challenge
logger.info(" Skip missing {}".format(chlng))
queued_processes -= 1
control_queue.task_done()
logger.info("Terminated")
control_stream.terminate()
control_stream.join()
def start(li, user_profile, max_games, max_queued, engine_factory, config):
# init
username = user_profile.get("username")
print("Welcome {}!".format(username))
manager = multiprocessing.Manager()
challenge_queue = []
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream,
args=[control_queue, li])
control_stream.start()
busy_processes = 0
queued_processes = 0
with logging_pool.LoggingPool(max_games + 1) as pool:
events = li.get_event_stream().iter_lines()
quit = False
while not quit:
event = control_queue.get()
if event["type"] == "local_game_done":
busy_processes -= 1
print("+++ Process Free. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if len(challenge_queue) < max_queued and can_accept_challenge(
chlng, config):
challenge_queue.append(chlng)
print(" Queue {}".format(chlng.show()))
else:
print(" Decline {}".format(chlng.show()))
li.decline_challenge(chlng.id)
elif event["type"] == "gameStart":
if queued_processes <= 0:
print(
"Something went wrong. Game is starting and we don't have a queued process"
)
else:
queued_processes -= 1
game_id = event["game"]["id"]
pool.apply_async(play_game,
[li, game_id, control_queue, engine_factory])
busy_processes += 1
print("--- Process Used. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
if (queued_processes +
busy_processes) < max_games and challenge_queue:
chlng = challenge_queue.pop(0)
print(" Accept {}".format(chlng.show()))
response = li.accept_challenge(chlng.id)
if response is not None:
# TODO: Probably warrants better checking.
queued_processes += 1
print(
"--- Process Queue. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
control_stream.terminate()
control_stream.join()
def start(li, user_profile, max_games, engine_factory, config):
# init
print("You're now connected to {} and awaiting challenges.".format(config["url"]))
manager = multiprocessing.Manager()
challenge_queue = []
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream, args=[control_queue, li])
control_stream.start()
busy_processes = 0
queued_processes = 0
with logging_pool.LoggingPool(max_games+1) as pool:
while True:
event = control_queue.get()
if event["type"] == "local_game_done":
busy_processes -= 1
print("+++ Process Free. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(config):
challenge_queue.append(chlng)
if (config.get("sort_challenges_by") != "first"):
challenge_queue.sort(key=lambda c: -c.score())
else:
try:
li.decline_challenge(chlng.id)
print(" Decline {}".format(chlng))
except HTTPError as exception:
if exception.response.status_code != 404: # ignore missing challenge
raise exception
elif event["type"] == "gameStart":
if queued_processes <= 0:
print("Something went wrong. Game is starting and we don't have a queued process")
else:
queued_processes -= 1
game_id = event["game"]["id"]
pool.apply_async(play_game, [li, game_id, control_queue, engine_factory, user_profile])
busy_processes += 1
print("--- Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
while ((queued_processes + busy_processes) < max_games and challenge_queue): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
response = li.accept_challenge(chlng.id)
print(" Accept {}".format(chlng))
queued_processes += 1
print("--- Process Queue. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
except HTTPError as exception:
if exception.response.status_code == 404: # ignore missing challenge
print(" Skip missing {}".format(chlng))
else:
raise exception
control_stream.terminate()
control_stream.join()
def start(li, user_profile, engine_path, weights=None, threads=None):
# init
username = user_profile.get("username")
print("Welcome {}!".format(username))
manager = multiprocessing.Manager()
challenge_queue = manager.Queue(CONFIG["max_queued_challenges"])
with logging_pool.LoggingPool(CONFIG['max_concurrent_games'] + 1) as pool:
event_stream = li.get_event_stream()
events = event_stream.iter_lines()
results = []
for evnt in events:
if evnt:
event = json.loads(evnt.decode('utf-8'))
if event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if can_accept_challenge(chlng):
try:
challenge_queue.put_nowait(chlng)
print(" Queue {}".format(chlng.show()))
except queue.Full:
print(" Decline {}".format(chlng.show()))
li.decline_challenge(chlng.id)
else:
print(" Decline {}".format(chlng.show()))
li.decline_challenge(chlng.id)
if event["type"] == "gameStart":
game_id = event["game"]["id"]
r = pool.apply_async(
play_game,
[li, game_id, weights, threads, challenge_queue])
results.append(r)
results = clear_finished_games(results)
if len(results) < CONFIG["max_concurrent_games"]:
accept_next_challenge(challenge_queue)
def start(li, user_profile, engine_factory, config, logging_level,
log_filename):
challenge_config = config["challenge"]
max_games = challenge_config.get("concurrency", 1)
logger.info("You're now connected to {} and awaiting challenges.".format(
config["url"]))
manager = multiprocessing.Manager()
challenge_queue = manager.list()
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream,
args=[control_queue, li])
control_stream.start()
correspondence_cfg = config.get("correspondence", {}) or {}
correspondence_checkin_period = correspondence_cfg.get(
"checkin_period", 600)
correspondence_pinger = multiprocessing.Process(
target=do_correspondence_ping,
args=[control_queue, correspondence_checkin_period])
correspondence_pinger.start()
correspondence_queue = manager.Queue()
correspondence_queue.put("")
wait_for_correspondence_ping = False
busy_processes = 0
queued_processes = 0
logging_queue = manager.Queue()
logging_listener = multiprocessing.Process(
target=logging_listener_proc,
args=(logging_queue, listener_configurer, logging_level, log_filename))
logging_listener.start()
with logging_pool.LoggingPool(max_games + 1) as pool:
while not terminated:
try:
event = control_queue.get()
except InterruptedError:
continue
if event["type"] == "terminated":
break
elif event["type"] == "local_game_done":
busy_processes -= 1
logger.info(
"+++ Process Free. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(challenge_config):
challenge_queue.append(chlng)
if (challenge_config.get("sort_by", "best") == "best"):
list_c = list(challenge_queue)
list_c.sort(key=lambda c: -c.score())
challenge_queue = list_c
else:
try:
li.decline_challenge(chlng.id)
logger.info("Decline {}".format(chlng))
except:
pass
elif event["type"] == "gameStart":
if queued_processes <= 0:
logger.debug(
"Something went wrong. Game is starting and we don't have a queued process"
)
else:
queued_processes -= 1
busy_processes += 1
logger.info(
"--- Process Used. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
game_id = event["game"]["id"]
pool.apply_async(play_game, [
li, game_id, control_queue, engine_factory, user_profile,
config, challenge_queue, correspondence_queue,
logging_queue, game_logging_configurer, logging_level
])
if event["type"] == "correspondence_ping" or (
event["type"] == "local_game_done"
and not wait_for_correspondence_ping):
if event[
"type"] == "correspondence_ping" and wait_for_correspondence_ping:
correspondence_queue.put("")
wait_for_correspondence_ping = False
while (busy_processes + queued_processes) < max_games:
game_id = correspondence_queue.get()
# stop checking in on games if we have checked in on all games since the last correspondence_ping
if not game_id:
wait_for_correspondence_ping = True
break
else:
busy_processes += 1
logger.info(
"--- Process Used. Total Queued: {}. Total Used: {}"
.format(queued_processes, busy_processes))
pool.apply_async(play_game, [
li, game_id, control_queue, engine_factory,
user_profile, config, challenge_queue,
correspondence_queue, logging_queue,
game_logging_configurer, logging_level
])
while (
(queued_processes + busy_processes) < max_games
and challenge_queue
): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
logger.info("Accept {}".format(chlng))
queued_processes += 1
li.accept_challenge(chlng.id)
logger.info(
"--- Process Queue. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
except (HTTPError, ReadTimeout) as exception:
if isinstance(
exception, HTTPError
) and exception.response.status_code == 404: # ignore missing challenge
logger.info("Skip missing {}".format(chlng))
queued_processes -= 1
control_queue.task_done()
logger.info("Terminated")
control_stream.terminate()
control_stream.join()
correspondence_pinger.terminate()
correspondence_pinger.join()
logging_listener.terminate()
logging_listener.join()
def start(li, user_profile, engine_factory, config):
challenge_config = config["challenge"]
max_games = challenge_config.get("concurrency", 1)
print("You're now connected to {} and awaiting challenges.".format(
config["url"]))
manager = multiprocessing.Manager()
challenge_queue = []
control_queue = manager.Queue()
#control_stream = multiprocessing.Process(target=watch_control_stream, args=[control_queue, li])
#control_stream.start()
control_stream = threading.Thread(target=watch_control_stream,
args=(control_queue, li))
control_stream.daemon = True
control_stream.start()
print("control stream started")
busy_processes = 0
queued_processes = 0
def cmd_thread_func():
while True:
cmd = input("").rstrip()
if cmd == "x" or cmd == "X":
print("exiting lichess-bot...")
control_queue.put_nowait({"type": "exit"})
break
threading.Thread(target=cmd_thread_func).start()
with logging_pool.LoggingPool(max_games + 1) as pool:
while True:
event = control_queue.get()
if event["type"] == "exit":
break
elif event["type"] == "local_game_done":
busy_processes -= 1
print("+++ Process Free. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(challenge_config):
challenge_queue.append(chlng)
if (challenge_config.get("sort_by", "best") == "best"):
challenge_queue.sort(key=lambda c: -c.score())
else:
try:
li.decline_challenge(chlng.id)
print(" Decline {}".format(chlng))
except HTTPError as exception:
if exception.response.status_code != 404: # ignore missing challenge
raise exception
elif event["type"] == "gameStart":
print("game start")
if queued_processes <= 0:
print(
"Something went wrong. Game is starting and we don't have a queued process"
)
else:
queued_processes -= 1
game_id = event["game"]["id"]
gt = threading.Thread(target=play_game,
args=(li, game_id, control_queue,
engine_factory, user_profile,
config))
gt.daemon = True
gt.start()
busy_processes += 1
print("--- Process Used. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
while (
(queued_processes + busy_processes) < max_games
and challenge_queue
): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
response = li.accept_challenge(chlng.id)
print(" Accept {}".format(chlng))
queued_processes += 1
print(
"--- Process Queue. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
except HTTPError as exception:
if exception.response.status_code == 404: # ignore missing challenge
print(" Skip missing {}".format(chlng))
else:
raise exception
def start(li, user_profile, engine_factory, config):
challenge_config = config["challenge"]
max_games = challenge_config.get("concurrency", 1)
logger.info("You're now connected to {} and awaiting challenges.".format(config["url"]))
manager = multiprocessing.Manager()
challenge_queue = manager.list()
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream, args=[control_queue, li])
control_stream.start()
busy_processes = 0
queued_processes = 0
with logging_pool.LoggingPool(max_games+1) as pool:
while not terminated:
event = control_queue.get()
logger.info("||| control_queue event: %s" % event["type"])
if event["type"] == "terminated":
break
elif event["type"] == "ping":
# li.pong()
continue
# elif event["type"] == "connected":
# for variant in challenge_config["variants"]:
# logger.info("Creating seek for %s" % variant)
# li.create_seek(variant)
elif event["type"] == "local_game_done":
busy_processes -= 1
logger.info("+++ Process Free. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(challenge_config):
challenge_queue.append(chlng)
if (challenge_config.get("sort_by", "best") == "best"):
list_c = list(challenge_queue)
list_c.sort(key=lambda c: -c.score())
challenge_queue = list_c
else:
try:
li.decline_challenge(chlng.id)
logger.info(" Decline {}".format(chlng))
except HTTPError as exception:
if exception.response.status_code != 404: # ignore missing challenge
raise exception
elif event["type"] == "gameStart":
if queued_processes <= 0:
logger.debug("Something went wrong. Game is starting and we don't have a queued process")
else:
queued_processes -= 1
game_id = event["game"]["id"]
try:
skill_level = int(event["game"]["skill_level"])
except Exception:
skill_level = 8
# try:
# chess960 = event["game"]["chess960"] == "True"
# except Exception:
# chess960 = False
pool.apply_async(play_game, [li, game_id, control_queue, engine_factory, user_profile, config, challenge_queue, skill_level, chess960])
busy_processes += 1
logger.info("--- Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
elif event["type"] == "analysisStart":
if queued_processes <= 0:
logger.debug("Something went wrong. Game analysis is starting and we don't have a queued process")
else:
queued_processes -= 1
game_id = event["game"]["id"]
try:
skill_level = int(event["game"]["skill_level"])
except Exception:
skill_level = 8
# try:
# chess960 = event["game"]["chess960"] == "True"
# except Exception:
# chess960 = False
pool.apply_async(analyze_game, [li, game_id, control_queue, engine_factory, user_profile, config, skill_level, chess960, event["username"]])
busy_processes += 1
logger.info("--- Analysis Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
while ((queued_processes + busy_processes) < max_games and challenge_queue): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
response = li.accept_challenge(chlng.id)
logger.info(" Accept {}".format(chlng))
queued_processes += 1
logger.info("--- Process Queue. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
except HTTPError as exception:
if exception.response.status_code == 404: # ignore missing challenge
logger.info(" Skip missing {}".format(chlng))
else:
raise exception
logger.info("Terminated")
control_stream.terminate()
control_stream.join()
def watch_control_stream(control_queue, li):
with logging_pool.LoggingPool(CONFIG['max_concurrent_games']+1) as pool:
for evnt in li.get_event_stream().iter_lines():
if evnt:
event = json.loads(evnt.decode('utf-8'))
control_queue.put_nowait(event)
def start(li, user_profile, engine_factory, config, logging_level, log_filename):
challenge_config = config["challenge"]
max_games = challenge_config.get("concurrency", 1)
logger.info("You're now connected to {} and awaiting challenges.".format(config["url"]))
manager = multiprocessing.Manager()
challenge_queue = manager.list()
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream, args=[control_queue, li])
control_stream.start()
correspondence_cfg = config.get("correspondence", {}) or {}
correspondence_checkin_period = correspondence_cfg.get("checkin_period", 600)
correspondence_pinger = multiprocessing.Process(target=do_correspondence_ping, args=[control_queue, correspondence_checkin_period])
correspondence_pinger.start()
correspondence_queue = manager.Queue()
correspondence_queue.put("")
wait_for_correspondence_ping = False
busy_processes = 0
queued_processes = 0
logging_queue = manager.Queue()
logging_listener = multiprocessing.Process(target=logging_listener_proc, args=(logging_queue, listener_configurer, logging_level, log_filename))
logging_listener.start()
with logging_pool.LoggingPool(max_games + 1) as pool:
while not terminated:
try:
event = control_queue.get()
except InterruptedError:
continue
if event.get("type") is None:
logger.warning("Unable to handle response from lichess.org:")
logger.warning(event)
if event.get("error") == "Missing scope":
logger.warning('Please check that the API access token for your bot has the scope "Play games with the bot API".')
continue
if event["type"] == "terminated":
break
elif event["type"] == "local_game_done":
busy_processes -= 1
logger.info("+++ Process Free. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if chlng.is_supported(challenge_config):
challenge_queue.append(chlng)
if (challenge_config.get("sort_by", "best") == "best"):
list_c = list(challenge_queue)
list_c.sort(key=lambda c: -c.score())
challenge_queue = list_c
else:
try:
reason = "generic"
challenge = config["challenge"]
if not chlng.is_supported_variant(challenge["variants"]):
reason = "variant"
if not chlng.is_supported_time_control(challenge["time_controls"], challenge.get("max_increment", 180), challenge.get("min_increment", 0), challenge.get("max_base", 315360000), challenge.get("min_base", 0)):
reason = "timeControl"
if not chlng.is_supported_mode(challenge["modes"]):
reason = "casual" if chlng.rated else "rated"
if not challenge.get("accept_bot", False) and chlng.challenger_is_bot:
reason = "noBot"
if challenge.get("only_bot", False) and not chlng.challenger_is_bot:
reason = "onlyBot"
li.decline_challenge(chlng.id, reason=reason)
logger.info("Decline {} for reason '{}'".format(chlng, reason))
except Exception:
pass
elif event["type"] == "gameStart":
if queued_processes <= 0:
logger.debug("Something went wrong. Game is starting and we don't have a queued process")
else:
queued_processes -= 1
busy_processes += 1
logger.info("--- Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
game_id = event["game"]["id"]
pool.apply_async(play_game, [li, game_id, control_queue, engine_factory, user_profile, config, challenge_queue, correspondence_queue, logging_queue, game_logging_configurer, logging_level])
if (event["type"] == "correspondence_ping" or (event["type"] == "local_game_done" and not wait_for_correspondence_ping)) and not challenge_queue:
if event["type"] == "correspondence_ping" and wait_for_correspondence_ping:
correspondence_queue.put("")
wait_for_correspondence_ping = False
while (busy_processes + queued_processes) < max_games:
game_id = correspondence_queue.get()
# stop checking in on games if we have checked in on all games since the last correspondence_ping
if not game_id:
wait_for_correspondence_ping = True
break
else:
busy_processes += 1
logger.info("--- Process Used. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
pool.apply_async(play_game, [li, game_id, control_queue, engine_factory, user_profile, config, challenge_queue, correspondence_queue, logging_queue, game_logging_configurer, logging_level])
while ((queued_processes + busy_processes) < max_games and challenge_queue): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
logger.info("Accept {}".format(chlng))
queued_processes += 1
li.accept_challenge(chlng.id)
logger.info("--- Process Queue. Total Queued: {}. Total Used: {}".format(queued_processes, busy_processes))
except (HTTPError, ReadTimeout) as exception:
if isinstance(exception, HTTPError) and exception.response.status_code == 404: # ignore missing challenge
logger.info("Skip missing {}".format(chlng))
queued_processes -= 1
control_queue.task_done()
logger.info("Terminated")
control_stream.terminate()
control_stream.join()
correspondence_pinger.terminate()
correspondence_pinger.join()
logging_listener.terminate()
logging_listener.join()
print(bot_move)
make_move(game_id, bot_move)
fens.append(board.fen()[:-9].strip())
if __name__ == '__main__':
manager = multiprocessing.Manager()
challenge_queue = []
event_queue = manager.Queue()
control_stream = multiprocessing.Process(target=stream_events,
args=[event_queue])
control_stream.start()
with logging_pool.LoggingPool(10) as pool:
while True:
event = event_queue.get()
if event['type'] == 'challenge' and (
(event['challenge']['variant']['key'] == 'standard') or
(event['challenge']['variant']['key'] == 'atomic') or
(event['challenge']['variant']['key'] == 'antichess') or
(event['challenge']['variant']['key'] == 'threeCheck')):
_id = event['challenge']['id'].strip()
accept_challenge(_id)
elif event['type'] == 'gameStart':
game_id = event['game']['id']
pool.apply_async(play_game, [game_id, event_queue])
def start(li, user_profile, max_games, max_queued, engine_factory, config):
# init
username = user_profile.get("username")
print("Welcome {}!".format(username))
manager = multiprocessing.Manager()
challenge_queue = []
control_queue = manager.Queue()
control_stream = multiprocessing.Process(target=watch_control_stream,
args=[control_queue, li])
control_stream.start()
busy_processes = 0
queued_processes = 0
with logging_pool.LoggingPool(max_games + 1) as pool:
events = li.get_event_stream().iter_lines()
quit = False
while not quit:
event = control_queue.get()
if event["type"] == "local_game_done":
busy_processes -= 1
print("+++ Process Free. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
elif event["type"] == "challenge":
chlng = model.Challenge(event["challenge"])
if len(challenge_queue) < max_queued and can_accept_challenge(
chlng, config):
challenge_queue.append(chlng)
print(" Queue {}".format(chlng.show()))
else:
try:
li.decline_challenge(chlng.id)
print(" Decline {}".format(chlng.show()))
except HTTPError as exception:
if exception.response.status_code != 404: # ignore missing challenge
raise exception
elif event["type"] == "gameStart":
if queued_processes <= 0:
print(
"Something went wrong. Game is starting and we don't have a queued process"
)
else:
queued_processes -= 1
game_id = event["game"]["id"]
pool.apply_async(play_game,
[li, game_id, control_queue, engine_factory])
busy_processes += 1
print("--- Process Used. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
while (
(queued_processes + busy_processes) < max_games
and challenge_queue
): # keep processing the queue until empty or max_games is reached
chlng = challenge_queue.pop(0)
try:
response = li.accept_challenge(chlng.id)
print(" Accept {}".format(chlng.show()))
queued_processes += 1
print(
"--- Process Queue. Total Queued: {}. Total Used: {}".
format(queued_processes, busy_processes))
except HTTPError as exception:
if exception.response.status_code == 404: # ignore missing challenge
print(" Skip missing {}".format(chlng.show()))
else:
raise exception
control_stream.terminate()
control_stream.join()
