Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
engine._new(board, game, options)
# Limit or time control.
increment = limit.white_inc if board.turn else limit.black_inc
if limit.remaining_moves or increment:
base_mins, base_secs = divmod(int(limit.white_clock if board.turn else limit.black_clock), 60)
engine.send_line("level {} {}:{:02d} {}".format(limit.remaining_moves or 0, base_mins, base_secs, increment))
if limit.nodes is not None:
if limit.time is not None or limit.white_clock is not None or limit.black_clock is not None or increment is not None:
raise EngineError("xboard does not support mixing node limits with time limits")
if "nps" not in engine.features:
LOGGER.warning("%s: Engine did not declare explicit support for node limits (feature nps=?)")
elif not engine.features["nps"]:
raise EngineError("xboard engine does not support node limits (feature nps=0)")
engine.send_line("nps 1")
engine.send_line("st {}".format(int(limit.nodes)))
if limit.depth is not None:
engine.send_line("sd {}".format(limit.depth))
if limit.time is not None:
engine.send_line("st {}".format(limit.time))
if limit.white_clock is not None:
engine.send_line("{} {}".format("time" if board.turn else "otim", int(limit.white_clock * 100)))
if limit.black_clock is not None:
engine.send_line("{} {}".format("otim" if board.turn else "time", int(limit.black_clock * 100)))
# Start thinking.
engine.send_line("post" if info else "nopost")
engine.send_line("hard" if ponder else "easy")
engine.send_line("go")
def _line_received(self, engine: EngineProtocolT, line: str) -> None:
assert self.state in [CommandState.Active, CommandState.Cancelling]
try:
self.line_received(engine, line)
except EngineError as err:
self._handle_exception(engine, err)
def _setoption(self, name: str, value: ConfigValue) -> None:
if value is not None and value == self.config.get(name):
return
try:
option = self.options[name]
except KeyError:
raise EngineError("unsupported xboard option or command: {}".format(name))
self.config[name] = value = option.parse(value)
if name in ["random", "computer"]:
# Applied in _new.
pass
elif name in ["memory", "cores"] or name.startswith("egtpath "):
self.send_line("{} {}".format(name, value))
elif value is None:
self.send_line("option {}".format(name))
elif value is True:
self.send_line("option {}=1".format(name))
elif value is False:
self.send_line("option {}=0".format(name))
else:
self.send_line("option {}={}".format(name, value))
def end(self, engine: XBoardProtocol) -> None:
if not engine.features.get("ping", 0):
self.result.set_exception(EngineError("xboard engine did not declare required feature: ping"))
self.set_finished()
return
if not engine.features.get("setboard", 0):
self.result.set_exception(EngineError("xboard engine did not declare required feature: setboard"))
self.set_finished()
return
if not engine.features.get("reuse", 1):
LOGGER.warning("%s: Rejecting feature reuse=0", engine)
engine.send_line("reject reuse")
if not engine.features.get("sigterm", 1):
LOGGER.warning("%s: Rejecting feature sigterm=0", engine)
engine.send_line("reject sigterm")
if engine.features.get("usermove", 0):
LOGGER.warning("%s: Rejecting feature usermove=1", engine)
engine.send_line("reject usermove")
if engine.features.get("san", 0):
LOGGER.warning("%s: Rejecting feature san=1", engine)
engine.send_line("reject san")
if self.type == "check":
return value and value != "false"
elif self.type == "spin":
try:
value = int(value)
except ValueError:
raise EngineError("expected integer for spin option {!r}, got: {!r}".format(self.name, value))
if self.min is not None and value < self.min:
raise EngineError("expected value for option {!r} to be at least {}, got: {}".format(self.name, self.min, value))
if self.max is not None and self.max < value:
raise EngineError("expected value for option {!r} to be at most {}, got: {}".format(self.name, self.max, value))
return value
elif self.type == "combo":
value = str(value)
if value not in (self.var or []):
raise EngineError("invalid value for combo option {!r}, got: {} (available: {})".format(self.name, value, ", ".join(self.var)))
return value
elif self.type in ["button", "reset", "save"]:
return None
elif self.type in ["string", "file", "path"]:
value = str(value)
if "\n" in value or "\r" in value:
raise EngineError("invalid line-break in string option {!r}: {!r}".format(self.name, value))
return value
else:
raise EngineError("unknown option type: {}", self.type)
def _bestmove(self, engine: UciProtocol, arg: str) -> None:
if not self.result.done():
raise EngineError("was not searching, but engine sent bestmove")
self.set_finished()
self.analysis.set_finished()
def end(self, engine: XBoardProtocol) -> None:
if not engine.features.get("ping", 0):
self.result.set_exception(EngineError("xboard engine did not declare required feature: ping"))
self.set_finished()
return
if not engine.features.get("setboard", 0):
self.result.set_exception(EngineError("xboard engine did not declare required feature: setboard"))
self.set_finished()
return
if not engine.features.get("reuse", 1):
LOGGER.warning("%s: Rejecting feature reuse=0", engine)
engine.send_line("reject reuse")
if not engine.features.get("sigterm", 1):
LOGGER.warning("%s: Rejecting feature sigterm=0", engine)
engine.send_line("reject sigterm")
if engine.features.get("usermove", 0):
LOGGER.warning("%s: Rejecting feature usermove=1", engine)
engine.send_line("reject usermove")
def _setoption(self, name: str, value: ConfigValue) -> None:
try:
value = self.options[name].parse(value)
except KeyError:
raise EngineError("engine does not support option {} (available options: {})".format(name, ", ".join(self.options)))
if value is None or value != self.config.get(name):
builder = ["setoption name", name]
if value is False:
builder.append("value false")
elif value is True:
builder.append("value true")
elif value is not None:
builder.append("value")
builder.append(str(value))
self.send_line(" ".join(builder))
self.config[name] = value