def coro():
gamemodel = GameModel(TimeModel(1, 0))
player0tup = (LOCAL, Human, (WHITE, "w"), "w")
player1tup = (LOCAL, Human, (BLACK, "b"), "b")
def on_game_end(game, state, event):
event.set()
event = asyncio.Event()
gamemodel.connect("game_ended", on_game_end, event)
def on_players_changed(game):
# fill fools mate moves to players move queue
p0 = game.players[0]
p0.move_queue.put_nowait(Move(newMove(F2, F3)))
p0.move_queue.put_nowait(Move(newMove(G2, G4)))
p1 = gamemodel.players[1]
p1.move_queue.put_nowait(Move(newMove(E7, E5)))
p1.move_queue.put_nowait(Move(newMove(D8, H4)))
gamemodel.connect("players_changed", on_players_changed)
create_task(self.games_persp.generalStart(gamemodel, player0tup, player1tup))
# waiting for game end ...
yield from event.wait()
fen = "rnb1kbnr/pppp1ppp/8/4p3/6Pq/5P2/PPPPP2P/RNBQKBNR w KQkq - 1 3"
self.assertEqual(gamemodel.boards[-1].board.asFen(), fen)
# Now save our game to pychess.pgn
self.games_persp.saveGamePGN(gamemodel)
def startClicked(self, button):
color = self.widgets["colorDock"].get_child().get_active()
if color == 2:
color = random.choice([WHITE, BLACK])
opp = self.widgets["opponentDock"].get_child()
tree_iter = opp.get_active_iter()
if tree_iter is not None:
model = opp.get_model()
engine = model[tree_iter][1]
opponent = self.widgets["opponentDock"].get_child().get_active()
difficulty = int(self.widgets["skillSlider"].get_value())
gamemodel = GameModel(TimeModel(5 * 60, 0))
name = conf.get("firstName")
player0tup = (LOCAL, Human, (color, name), name)
if opponent == 0:
name = conf.get("secondName")
player1tup = (LOCAL, Human, (1 - color, name), name)
else:
engine = discoverer.getEngineByName(engine)
name = discoverer.getName(engine)
player1tup = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, 1 - color, difficulty,
variants[NORMALCHESS], 5 * 60, 0), name)
perspective = perspective_manager.get_perspective("games")
if color == WHITE:
create_task(perspective.generalStart(gamemodel, player0tup, player1tup))
else:
create_task(perspective.generalStart(gamemodel, player1tup, player0tup))
def discover(self):
self.pre_discover()
def count(self_, name, engine, wentwell):
if not wentwell:
print("count() not went well on engine", name)
self.engines.remove(engine)
self.toBeRechecked[name][1] = True
if all([elem[1] for elem in self.toBeRechecked.values()]):
self.engines.sort(key=lambda x: x["name"])
self.emit("all_engines_discovered")
createStoryTextAppEvent("all_engines_discovered")
self.connect("engine_discovered", count, True)
self.connect("engine_failed", count, False)
if self.toBeRechecked:
self.emit("discovering_started", self.toBeRechecked.keys())
self.connect("all_engines_discovered", self.save)
for engine, done in self.toBeRechecked.values():
if not done:
create_task(self.__discoverE(engine))
else:
self.emit("all_engines_discovered")
createStoryTextAppEvent("all_engines_discovered")
def putMessage(self, message):
def answer(message):
try:
data = (urlopen(
"https://www.pandorabots.com/pandora/talk?botid=8d034368fe360895",
urlencode({
"message": message,
"botcust2": "x"
}).encode("utf-8"),
).read().decode("utf-8"))
except IOError as err:
log.warning(
"Couldn't answer message from online bot: '%s'" % err,
extra={"task": self.defname},
)
return
sstring = "<b>DMPGirl:</b>"
estring = "<br>"
answer = data[data.find(sstring) +
len(sstring):data.find(estring, data.find(sstring))]
self.emit("offer", Offer(CHAT_ACTION, answer))
@asyncio.coroutine
def get_answer(message):
loop = asyncio.get_event_loop()
future = loop.run_in_executor(None, answer, message)
yield from future
create_task(get_answer(message))
def onHelperConnectionError(self, connection, error):
if self.helperconn is not None:
dialog = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(_("Guest logins disabled by FICS server"))
text = "PyChess can maintain users status and games list only if it changes\n\
'open', 'gin' and 'availinfo' user variables.\n\
Do you enable to set these variables on?"
dialog.format_secondary_text(text)
response = dialog.run()
dialog.destroy()
self.helperconn.cancel()
self.helperconn.close()
self.helperconn = None
set_user_vars = response == Gtk.ResponseType.YES
@asyncio.coroutine
def coro():
yield from self.main_connected_event.wait()
self.connection.start_helper_manager(set_user_vars)
create_task(coro())
def discover(self):
self.pre_discover()
def count(self_, name, engine, wentwell):
if not wentwell:
print("cout not wentwell on engine", name)
self.engines.remove(engine)
self.toBeRechecked[name][1] = True
if all([elem[1] for elem in self.toBeRechecked.values()]):
self.engines.sort(key=lambda x: x["name"])
self.emit("all_engines_discovered")
createStoryTextAppEvent("all_engines_discovered")
self.connect("engine_discovered", count, True)
self.connect("engine_failed", count, False)
if self.toBeRechecked:
self.emit("discovering_started", self.toBeRechecked.keys())
self.connect("all_engines_discovered", self.save)
for engine, done in self.toBeRechecked.values():
if not done:
create_task(self.__discoverE(engine))
else:
self.emit("all_engines_discovered")
createStoryTextAppEvent("all_engines_discovered")
def onGamePreview(self, adm, ficsgame):
log.debug("Archived panel onGamePreview: %s" % ficsgame)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
# The players need to start listening for moves IN this method if they
# want to be noticed of all moves the FICS server sends us from now on.
# Hence the lazy loading is skipped.
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
player0tup = (REMOTE, ICPlayer,
(gamemodel, wplayer.name, -1, WHITE, wplayer.long_name(),
wplayer.getRatingByGameType(ficsgame.game_type)),
wplayer.long_name())
player1tup = (REMOTE, ICPlayer,
(gamemodel, bplayer.name, -1, BLACK, bplayer.long_name(),
bplayer.getRatingByGameType(ficsgame.game_type)),
bplayer.long_name())
perspective = perspective_manager.get_perspective("games")
create_task(
perspective.generalStart(
gamemodel, player0tup, player1tup,
(StringIO(ficsgame.board.pgn), pgn, 0, -1)))
gamemodel.connect("game_started", self.on_game_start, ficsgame)
def row_activated(self, widget, path, col):
rec, ply = self.get_record(path)
if rec is None:
return
# Enable unfinished games to continue from newgamedialog
if rec["Result"] not in UNDOABLE_STATES:
newGameDialog.EnterNotationExtension.run()
model = self.persp.chessfile.loadToModel(rec)
text = pgn.save(StringIO(), model)
newGameDialog.EnterNotationExtension.sourcebuffer.set_text(text)
return
self.gamemodel = GameModel()
variant = rec["Variant"]
if variant:
self.gamemodel.tags["Variant"] = variant
# Lichess exports study .pgn without White and Black tags
wp = "" if rec["White"] is None else rec["White"]
bp = "" if rec["Black"] is None else rec["Black"]
p0 = (LOCAL, Human, (WHITE, wp), wp)
p1 = (LOCAL, Human, (BLACK, bp), bp)
self.persp.chessfile.loadToModel(rec, -1, self.gamemodel)
self.gamemodel.endstatus = (self.gamemodel.status
if self.gamemodel.status in UNDOABLE_STATES
else None)
self.gamemodel.status = WAITING_TO_START
perspective_manager.activate_perspective("games")
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(self.gamemodel, p0, p1))
def start(self):
def coro():
self.emit("game_started")
while True:
player0, player1 = yield from self.curplayer.make_move()
if isinstance(player0, SetupMove):
# print(player0.cord0, player0.cord1, player1)
new_board = self.boards[-1].move(player0, player1)
self.moves.append(player0)
self.boards.append(new_board)
self.emit("game_changed", self.ply)
elif player0 == "SETUP":
# print("SETUP", player0, player1)
self.emit("game_ended", 0)
self.boards = [self.variant(setup=player1)]
self.variations = [self.boards]
self.emit("game_loaded", 0)
self.emit("game_started")
self.emit("game_changed", 0)
elif player0 == "CLOSE":
# print("CLOSE")
break
create_task(coro())
def on_close_clicked(self, button):
@asyncio.coroutine
def coro():
altpath = getEngineDataPrefix()
if pgn.scoutfish_path is None and conf.get("download_scoutfish"):
binary = "https://github.com/pychess/scoutfish/releases/download/20170627/%s" % pgn.scoutfish
filename = yield from download_file_async(binary)
if filename is not None:
dest = shutil.move(filename, os.path.join(altpath, pgn.scoutfish))
os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
pgn.scoutfish_path = dest
if pgn.chess_db_path is None and conf.get("download_chess_db"):
binary = "https://github.com/pychess/chess_db/releases/download/20170627/%s" % pgn.parser
filename = yield from download_file_async(binary)
if filename is not None:
dest = shutil.move(filename, os.path.join(altpath, pgn.parser))
os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
pgn.chess_db_path = dest
if TimeSeal.timestamp_path is None and conf.get("download_timestamp"):
binary = "http://download.chessclub.com.s3.amazonaws.com/timestamp/%s" % TimeSeal.timestamp
filename = yield from download_file_async(binary)
if filename is not None:
dest = shutil.move(filename, os.path.join(altpath, TimeSeal.timestamp))
os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
TimeSeal.timestamp_path = dest
create_task(coro())
self.window.emit("delete-event", None)
def start_endgame_from(pieces):
fen = create_fen(pieces)
timemodel = TimeModel(0, 0)
gamemodel = LearnModel(timemodel)
gamemodel.set_learn_data(ENDGAME, pieces)
player_name = conf.get("firstName")
p0 = (LOCAL, Human, (WHITE, player_name), player_name)
engine = discoverer.getEngineByName(discoverer.getEngineLearn())
ponder_off = True
engine_name = discoverer.getName(engine)
p1 = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, BLACK, 20, variants[NORMALCHESS], 60, 0, 0, ponder_off), engine_name)
def restart_analyzer(gamemodel):
create_task(gamemodel.restart_analyzer(HINT))
gamemodel.connect("learn_success", restart_analyzer)
def on_game_started(gamemodel):
perspective.activate_panel("annotationPanel")
create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn()))
gamemodel.connect("game_started", on_game_started)
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, p0, p1, loaddata=(StringIO(fen), fen_loader, 0, -1)))
def on_game_started(gamemodel, name, color):
perspective.activate_panel("annotationPanel")
create_task(
gamemodel.start_analyzer(HINT,
force_engine=discoverer.getEngineLearn()))
gamemodel.players[1 - color].name = name
gamemodel.emit("players_changed")
def do_startup(self):
Gtk.Application.do_startup(self)
if self.purge_recent:
items = recent_manager.get_items()
for item in items:
uri = item.get_uri()
if item.get_application_info("pychess"):
recent_manager.remove_item(uri)
self.git_rev = ""
self.initGlade(self.log_viewer)
self.addPerspectives()
self.handleArgs(self.chess_file)
if self.version_check:
create_task(checkversion())
self.loaded_cids = {}
self.saved_cids = {}
self.terminated_cids = {}
log.info("PyChess %s %s git %s" %
(VERSION_NAME, VERSION, self.git_rev))
log.info("Command line args: '%s'" % self.chess_file)
log.info("Platform: %s" % platform.platform())
log.info("Python version: %s.%s.%s" % sys.version_info[0:3])
log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version)
log.info("Gtk version: %s.%s.%s" %
(Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
def startClicked(self, button):
color = self.widgets["colorDock"].get_child().get_active()
if color == 2:
color = random.choice([WHITE, BLACK])
opp = self.widgets["opponentDock"].get_child()
tree_iter = opp.get_active_iter()
if tree_iter is not None:
model = opp.get_model()
engine = model[tree_iter][1]
opponent = self.widgets["opponentDock"].get_child().get_active()
difficulty = int(self.widgets["skillSlider"].get_value())
gamemodel = GameModel(TimeModel(5 * 60, 0))
name = conf.get("firstName")
player0tup = (LOCAL, Human, (color, name), name)
if opponent == 0:
name = conf.get("secondName")
player1tup = (LOCAL, Human, (1 - color, name), name)
else:
engine = discoverer.getEngineByName(engine)
name = discoverer.getName(engine)
player1tup = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, 1 - color, difficulty,
variants[NORMALCHESS], 5 * 60, 0), name)
perspective = perspective_manager.get_perspective("games")
if color == WHITE:
create_task(
perspective.generalStart(gamemodel, player0tup, player1tup))
else:
create_task(
perspective.generalStart(gamemodel, player1tup, player0tup))
def anal_combo_set_value(combobox, value, show_arrow_check, analyzer_type):
engine = discoverer.getEngineByMd5(value)
if engine is None:
combobox.set_active(0)
# This return saves us from the None-engine being used
# in later code -Jonas Thiem
return
else:
try:
index = list(discoverer.getAnalyzers()).index(engine)
except ValueError:
index = 0
combobox.set_active(index)
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
for gmwidg in perspective.gamewidgets:
spectators = gmwidg.gamemodel.spectators
md5 = engine.get('md5')
if analyzer_type in spectators and \
spectators[analyzer_type].md5 != md5:
gmwidg.gamemodel.remove_analyzer(analyzer_type)
create_task(gmwidg.gamemodel.start_analyzer(analyzer_type))
if not widgets[show_arrow_check].get_active():
gmwidg.gamemodel.pause_analyzer(analyzer_type)
def do_startup(self):
Gtk.Application.do_startup(self)
if self.purge_recent:
items = recent_manager.get_items()
for item in items:
uri = item.get_uri()
if item.get_application_info("pychess"):
recent_manager.remove_item(uri)
self.git_rev = ""
self.initGlade(self.log_viewer)
self.addPerspectives()
self.handleArgs(self.chess_file)
create_task(checkversion())
self.loaded_cids = {}
self.saved_cids = {}
self.terminated_cids = {}
log.info("PyChess %s %s git %s" % (VERSION_NAME, VERSION, self.git_rev))
log.info("Command line args: '%s'" % self.chess_file)
log.info("Platform: %s" % platform.platform())
log.info("Python version: %s.%s.%s" % sys.version_info[0:3])
log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version)
log.info("Gtk version: %s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()))
def anal_combo_set_value(combobox, value, show_arrow_check, analyzer_type):
engine = discoverer.getEngineByMd5(value)
if engine is None:
combobox.set_active(0)
# This return saves us from the None-engine being used
# in later code -Jonas Thiem
return
else:
try:
index = list(discoverer.getAnalyzers()).index(engine)
except ValueError:
index = 0
combobox.set_active(index)
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
for gmwidg in perspective.gamewidgets:
spectators = gmwidg.gamemodel.spectators
md5 = engine.get('md5')
if analyzer_type in spectators and \
spectators[analyzer_type].md5 != md5:
gmwidg.gamemodel.remove_analyzer(analyzer_type)
create_task(gmwidg.gamemodel.start_analyzer(analyzer_type))
if not widgets[show_arrow_check].get_active():
gmwidg.gamemodel.pause_analyzer(analyzer_type)
def onObserveGameCreated(self, bm, ficsgame):
log.debug("FICS.onObserveGameCreated: %s" % ficsgame)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
gamemodel.connect("game_started", self.onGameModelStarted, ficsgame)
# The players need to start listening for moves IN this method if they
# want to be noticed of all moves the FICS server sends us from now on
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
player0tup = (
REMOTE,
ICPlayer,
(
gamemodel,
wplayer.name,
ficsgame.gameno,
WHITE,
wplayer.long_name(),
wplayer.getRatingForCurrentGame(),
),
wplayer.long_name(),
)
player1tup = (
REMOTE,
ICPlayer,
(
gamemodel,
bplayer.name,
ficsgame.gameno,
BLACK,
bplayer.long_name(),
bplayer.getRatingForCurrentGame(),
),
bplayer.long_name(),
)
perspective = perspective_manager.get_perspective("games")
create_task(
perspective.generalStart(
gamemodel,
player0tup,
player1tup,
(StringIO(ficsgame.board.pgn), pgn, 0, -1),
))
if ficsgame.relation == IC_POS_OBSERVING_EXAMINATION:
if 1: # int(self.connection.lvm.variablesBackup["kibitz"]) == 0:
self.connection.cm.whisper(
_("You have to set kibitz on to see bot messages here."))
self.connection.fm.finger(bplayer.name)
self.connection.fm.finger(wplayer.name)
elif ficsgame.relation == IC_POS_EXAMINATING:
gamemodel.examined = True
if not self.connection.ICC:
allob = "allob " + str(ficsgame.gameno)
gamemodel.connection.client.run_command(allob)
def load(self, persp):
self.persp = persp
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.tv = Gtk.TreeView()
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Title"), renderer, text=1)
self.tv.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Source"), renderer, text=2)
self.tv.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4)
column.set_expand(True)
self.tv.append_column(column)
renderer = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn(_("Reset"), renderer, icon_name=5)
column.set_name(COLUMN_ROW_RESET)
self.tv.append_column(column)
self.tv.connect("row-activated", self.row_activated)
def on_progress_updated(solving_progress, key, progress):
for i, row in enumerate(self.store):
if row[0] == key:
progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress)
treeiter = self.store.get_iter(Gtk.TreePath(i))
self.store[treeiter][3] = progress_ratio_string
self.store[treeiter][4] = percent
self.store[treeiter][5] = reset_icon
solving_progress.connect("progress_updated", on_progress_updated)
self.store = Gtk.ListStore(str, str, str, str, int, str)
@asyncio.coroutine
def coro():
for file_name, title, author in entries:
progress = solving_progress.get(file_name)
progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress)
self.store.append([file_name, title, author, progress_ratio_string, percent, reset_icon])
yield from asyncio.sleep(0)
create_task(coro())
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
self.tv.set_cursor(conf.get("learncombo%s" % learn_category_id))
scrollwin = Gtk.ScrolledWindow()
scrollwin.add(self.tv)
scrollwin.show_all()
self.box.pack_start(scrollwin, True, True, 0)
self.box.show_all()
return self.box
def setOptionInitialBoard(self, model):
@asyncio.coroutine
def coro():
yield from self.ready_moves_event.wait()
# We don't use the optionQueue here, as set board prints a whole lot of
# stuff. Instead we just call it.
self.setBoardList(model.boards[:], model.moves[:])
create_task(coro())
def learn_success(gamemodel):
gamemodel.scores = {}
chessfile.loadToModel(rec, -1, gamemodel)
progress = lessons_solving_progress[gamemodel.source]
progress[gamemodel.current_index] = 1
lessons_solving_progress[gamemodel.source] = progress
if "FEN" in gamemodel.tags:
create_task(gamemodel.restart_analyzer(HINT))
def loadPgnAndRun(data):
if data in [None, '']:
return False
perspective = perspective_manager.get_perspective("games")
p0 = (LOCAL, Human, (WHITE, _("White")), _("White"))
p1 = (LOCAL, Human, (BLACK, _("Black")), _("Black"))
create_task(perspective.generalStart(GameModel(), p0, p1, (StringIO(data), enddir['pgn'], 0, -1)))
return True
def learn_success(gamemodel):
gamemodel.scores = {}
chessfile.loadToModel(rec, -1, gamemodel)
progress = lessons_solving_progress[gamemodel.source]
progress[gamemodel.current_index] = 1
lessons_solving_progress[gamemodel.source] = progress
if "FEN" in gamemodel.tags:
create_task(gamemodel.restart_analyzer(HINT))
def on_subprocess(self, action, param):
proc = SubProcess("python", [
os.path.expanduser("~") +
"/pychess/lib/pychess/Players/PyChess.py",
])
create_task(self.parse_line(proc))
print("xboard", file=proc)
print("protover 2", file=proc)
def setOptionInitialBoard(self, model):
@asyncio.coroutine
def coro():
yield from self.ready_moves_event.wait()
# We don't use the optionQueue here, as set board prints a whole lot of
# stuff. Instead we just call it.
self.setBoardList(model.boards[:], model.moves[:])
create_task(coro())
def start_puzzle_game(gamemodel, filename, records, index, rec, from_lesson=False):
gamemodel.set_learn_data(PUZZLE, filename, index, len(records), from_lesson=from_lesson)
engine = discoverer.getEngineByName(discoverer.getEngineLearn())
ponder_off = True
color = gamemodel.boards[0].color
w_name = "" if rec["White"] is None else rec["White"]
b_name = "" if rec["Black"] is None else rec["Black"]
player_name = conf.get("firstName")
engine_name = discoverer.getName(engine)
if rec["Event"].startswith("Lichess Practice"):
w_name = player_name if color == WHITE else engine_name
b_name = engine_name if color == WHITE else player_name
opp_name = engine_name if rec["Event"].startswith("Lichess Practice") else b_name
if color == WHITE:
p0 = (LOCAL, Human, (WHITE, w_name), w_name)
p1 = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, BLACK, 20, variants[NORMALCHESS], 20, 0, 0, ponder_off), b_name)
else:
p0 = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, WHITE, 20, variants[NORMALCHESS], 20, 0, 0, ponder_off), w_name)
p1 = (LOCAL, Human, (BLACK, b_name), b_name)
def on_game_started(gamemodel, name, color):
perspective.activate_panel("annotationPanel")
create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn()))
gamemodel.players[1 - color].name = name
gamemodel.emit("players_changed")
gamemodel.connect("game_started", on_game_started, opp_name, color)
def goal_checked(gamemodle):
if gamemodel.reason == PRACTICE_GOAL_REACHED:
if from_lesson:
progress = lessons_solving_progress[gamemodel.source]
else:
progress = puzzles_solving_progress[gamemodel.source]
progress[gamemodel.current_index] = 1
if from_lesson:
lessons_solving_progress[gamemodel.source] = progress
else:
puzzles_solving_progress[gamemodel.source] = progress
gamemodel.connect("goal_checked", goal_checked)
gamemodel.variant.need_initial_board = True
gamemodel.status = WAITING_TO_START
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, p0, p1))
def setBoard(self, board, search=True):
def coro():
if self.engineIsAnalyzing:
self.__stop_analyze()
yield from asyncio.sleep(0.1)
self.setBoardList([board], [])
if search:
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
create_task(coro())
def coro():
def on_all_engines_discovered(discoverer, event):
event.set()
event = asyncio.Event()
discoverer.connect("all_engines_discovered", on_all_engines_discovered, event)
create_task(dd.start())
yield from event.wait()
def start(self):
assert not self.subproc
if sys.platform == "win32":
args = ["-t", self.host]
else:
args = ["-i10", self.host]
self.subproc = SubProcess(shutil.which("ping"), args, env={"LANG": "en"})
create_task(self.subproc.start())
self.conid1 = self.subproc.connect("line", self.__handleLines)
self.conid2 = self.subproc.connect("died", self.__handleDead)
def setBoard(self, board, search=True):
def coro():
if self.engineIsAnalyzing:
self.__stop_analyze()
yield from asyncio.sleep(0.1)
self.setBoardList([board], [])
if search:
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
create_task(coro())
def load(self, persp):
self.persp = persp
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.tv = Gtk.TreeView()
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Title"), renderer, text=1)
self.tv.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Source"), renderer, text=2)
self.tv.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4)
self.tv.append_column(column)
self.tv.connect("row-activated", self.row_activated)
def on_progress_updated(solving_progress, key, progress):
for i, row in enumerate(self.store):
if row[0] == key:
solved = progress.count(1)
percent = 0 if not solved else round((solved * 100.) / len(progress))
treeiter = self.store.get_iter(Gtk.TreePath(i))
self.store[treeiter][3] = "%s / %s" % (solved, len(progress))
self.store[treeiter][4] = percent
puzzles_solving_progress.connect("progress_updated", on_progress_updated)
self.store = Gtk.ListStore(str, str, str, str, int)
@asyncio.coroutine
def coro():
for file_name, title, author in PUZZLES:
progress = puzzles_solving_progress.get(file_name)
solved = progress.count(1)
percent = 0 if not solved else round((solved * 100.) / len(progress))
self.store.append([file_name, title, author, "%s / %s" % (solved, len(progress)), percent])
yield from asyncio.sleep(0)
create_task(coro())
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
self.tv.set_cursor(conf.get("learncombo%s" % PUZZLE))
scrollwin = Gtk.ScrolledWindow()
scrollwin.add(self.tv)
scrollwin.show_all()
self.box.pack_start(scrollwin, True, True, 0)
self.box.show_all()
return self.box
def start(self):
if self.finished:
self.close()
# let dialog window draw itself
yield from asyncio.sleep(0.1)
create_task(self.all_whatcher())
create_task(self.discovered_whatcher())
self.discoverer.discover()
async def coro():
def on_all_engines_discovered(discoverer, event):
event.set()
event = asyncio.Event()
discoverer.connect("all_engines_discovered",
on_all_engines_discovered, event)
create_task(dd.start())
await event.wait()
def loadFileAndRun(uri):
parts = splitUri(uri)
uri = parts[1] if len(parts) == 2 else parts[0]
loader = enddir[uri[uri.rfind(".") + 1:]]
timemodel = TimeModel(0, 0)
gamemodel = GameModel(timemodel)
white_name = _("White")
black_name = _("Black")
p0 = (LOCAL, Human, (WHITE, white_name), white_name)
p1 = (LOCAL, Human, (BLACK, black_name), black_name)
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, p0, p1, (uri, loader, 0, -1)))
def on_invanalyzer_check_toggled(check):
self.widgets["inv_analyzers_vbox"].set_sensitive(check.get_active())
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
create_task(gmwidg.gamemodel.restart_analyzer(SPY))
if not widgets["spy_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(SPY)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(SPY)
def start(self):
assert not self.subproc
if sys.platform == "win32":
args = ["-t", self.host]
else:
args = ["-i10", self.host]
self.subproc = SubProcess(shutil.which("ping"),
args,
env={"LANG": "en"})
create_task(self.subproc.start())
self.conid1 = self.subproc.connect("line", self.__handleLines)
self.conid2 = self.subproc.connect("died", self.__handleDead)
def on_invanalyzer_check_toggled(check):
self.widgets["inv_analyzers_vbox"].set_sensitive(check.get_active())
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
create_task(gmwidg.gamemodel.restart_analyzer(SPY))
if not widgets["spy_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(SPY)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(SPY)
def on_analyzer_check_toggled(check):
self.widgets["analyzers_vbox"].set_sensitive(check.get_active())
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
create_task(gmwidg.gamemodel.restart_analyzer(HINT))
if not widgets["hint_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(HINT)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(HINT)
def loadFileAndRun(uri):
parts = splitUri(uri)
uri = parts[1] if len(parts) == 2 else parts[0]
loader = enddir[uri[uri.rfind(".") + 1:]]
timemodel = TimeModel(0, 0)
gamemodel = GameModel(timemodel)
white_name = _("White")
black_name = _("Black")
p0 = (LOCAL, Human, (WHITE, white_name), white_name)
p1 = (LOCAL, Human, (BLACK, black_name), black_name)
perspective = perspective_manager.get_perspective("games")
create_task(
perspective.generalStart(gamemodel, p0, p1, (uri, loader, 0, -1)))
def on_analyzer_check_toggled(check):
self.widgets["analyzers_vbox"].set_sensitive(check.get_active())
from pychess.widgets.gamewidget import widgets
perspective = perspective_manager.get_perspective("games")
if len(perspective.gamewidgets) != 0:
if check.get_active():
for gmwidg in perspective.gamewidgets:
create_task(gmwidg.gamemodel.restart_analyzer(HINT))
if not widgets["hint_mode"].get_active():
gmwidg.gamemodel.pause_analyzer(HINT)
else:
for gmwidg in perspective.gamewidgets:
gmwidg.gamemodel.remove_analyzer(HINT)
def onConnectClicked(self, button):
self.canceled = False
self.widgets["messagePanel"].hide()
if self.widgets["logOnAsGuest"].get_active():
username = self.widgets["nameEntry"].get_text()
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
if port:
ports = (port, )
else:
ports = self.widgets["portsEntry"].get_text()
ports = list(map(int, re.findall("\d+", ports)))
if 5000 not in ports:
ports.append(5000)
if 23 not in ports:
ports.append(23)
alternate_host = self.widgets["hostEntry"].get_text()
timeseal = self.widgets["timesealCheck"].get_active()
self.showConnecting()
self.host = (host if host is not None else
alternate_host if alternate_host else "freechess.org")
self.connection = FICSMainConnection(self.host, ports, timeseal,
username, password)
for signal, callback in (
("connected", self.onConnected),
("error", self.onConnectionError),
("connectingMsg", self.showMessage),
):
self.cids[self.connection].append(
self.connection.connect(signal, callback))
self.main_connected_event = asyncio.Event()
self.connection_task = create_task(self.connection.start())
# guest users are rather limited on ICC (helper connection is useless)
if self.host not in ("localhost", "127.0.0.1", "chessclub.com"):
self.helperconn = FICSHelperConnection(self.connection, self.host,
ports, timeseal)
self.helperconn.connect("error", self.onHelperConnectionError)
@asyncio.coroutine
def coro():
yield from self.main_connected_event.wait()
yield from self.helperconn.start()
self.helperconn_task = create_task(coro())
def onPlayGameCreated(self, bm, ficsgame):
log.debug("FICS.onPlayGameCreated: %s" % ficsgame)
for message in self.messages:
message.dismiss()
del self.messages[:]
if self.connection.ICC:
for button in self.quick_seek_buttons:
button.set_active(False)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
gamemodel.connect("game_started", self.onGameModelStarted, ficsgame)
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
# We start
if wplayer.name.lower() == self.connection.getUsername().lower():
player0tup = (LOCAL, Human, (WHITE, wplayer.long_name(),
wplayer.name,
wplayer.getRatingForCurrentGame()),
wplayer.long_name())
player1tup = (REMOTE, ICPlayer,
(gamemodel, bplayer.name, ficsgame.gameno, BLACK,
bplayer.long_name(),
bplayer.getRatingForCurrentGame()),
bplayer.long_name())
# She starts
else:
player1tup = (LOCAL, Human, (BLACK, bplayer.long_name(),
bplayer.name,
bplayer.getRatingForCurrentGame()),
bplayer.long_name())
player0tup = (REMOTE, ICPlayer,
(gamemodel, wplayer.name, ficsgame.gameno, WHITE,
wplayer.long_name(),
wplayer.getRatingForCurrentGame()),
wplayer.long_name())
perspective = perspective_manager.get_perspective("games")
if not ficsgame.board.fen:
create_task(
perspective.generalStart(gamemodel, player0tup, player1tup))
else:
create_task(
perspective.generalStart(
gamemodel, player0tup, player1tup,
(StringIO(ficsgame.board.fen), fen, 0, -1)))
def putMove(self, board1, move, board2):
""" Sends the engine the last move made (for spectator engines).
@param board1: The current board
@param move: The last move made
@param board2: The board before the last move was made
"""
def coro():
if self.engineIsAnalyzing:
self.__stop_analyze()
yield from asyncio.sleep(0.1)
self.setBoardList([board1], [])
if not self.analyzing_paused:
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
create_task(coro())
def putMove(self, board1, move, board2):
""" Sends the engine the last move made (for spectator engines).
@param board1: The current board
@param move: The last move made
@param board2: The board before the last move was made
"""
def coro():
if self.engineIsAnalyzing:
self.__stop_analyze()
yield from asyncio.sleep(0.1)
self.setBoardList([board1], [])
if not self.analyzing_paused:
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
create_task(coro())
def game_ended(self, game):
if game in self:
if not game.move_queue.empty():
async def coro(game):
# we have to give a chance to ICPlayer
# to process the latest move(style12) message
# and remove game from game list panel also
await asyncio.sleep(0)
game = self[game]
self.emit("FICSGameEnded", game)
del self[game]
create_task(coro(game))
else:
game = self[game]
self.emit("FICSGameEnded", game)
del self[game]
def onPlayGameCreated(self, bm, ficsgame):
log.debug("FICS.onPlayGameCreated: %s" % ficsgame)
for message in self.messages:
message.dismiss()
del self.messages[:]
if self.connection.ICC:
for button in self.quick_seek_buttons:
button.set_active(False)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
gamemodel.connect("game_started", self.onGameModelStarted, ficsgame)
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
# We start
if wplayer.name.lower() == self.connection.getUsername().lower():
player0tup = (LOCAL, Human,
(WHITE, wplayer.long_name(), wplayer.name,
wplayer.getRatingForCurrentGame()),
wplayer.long_name())
player1tup = (REMOTE, ICPlayer, (
gamemodel, bplayer.name, ficsgame.gameno, BLACK,
bplayer.long_name(), bplayer.getRatingForCurrentGame()),
bplayer.long_name())
# She starts
else:
player1tup = (LOCAL, Human,
(BLACK, bplayer.long_name(), bplayer.name,
bplayer.getRatingForCurrentGame()),
bplayer.long_name())
player0tup = (REMOTE, ICPlayer, (
gamemodel, wplayer.name, ficsgame.gameno, WHITE,
wplayer.long_name(), wplayer.getRatingForCurrentGame()),
wplayer.long_name())
perspective = perspective_manager.get_perspective("games")
if not ficsgame.board.fen:
create_task(perspective.generalStart(gamemodel, player0tup, player1tup))
else:
create_task(perspective.generalStart(gamemodel, player0tup, player1tup, (
StringIO(ficsgame.board.fen), fen, 0, -1)))
def onConnectClicked(self, button):
self.canceled = False
self.widgets["messagePanel"].hide()
if self.widgets["logOnAsGuest"].get_active():
username = self.widgets["nameEntry"].get_text()
password = ""
else:
username = self.widgets["nameEntry"].get_text()
password = self.widgets["passEntry"].get_text()
if port:
ports = (port, )
else:
ports = self.widgets["portsEntry"].get_text()
ports = list(map(int, re.findall("\d+", ports)))
if 5000 not in ports:
ports.append(5000)
if 23 not in ports:
ports.append(23)
alternate_host = self.widgets["hostEntry"].get_text()
timeseal = self.widgets["timesealCheck"].get_active()
self.showConnecting()
self.host = host if host is not None else alternate_host if alternate_host else "freechess.org"
self.connection = FICSMainConnection(self.host, ports, timeseal, username, password)
for signal, callback in (("connected", self.onConnected),
("error", self.onConnectionError),
("connectingMsg", self.showMessage)):
self.cids[self.connection].append(self.connection.connect(signal, callback))
self.main_connected_event = asyncio.Event()
self.connection_task = create_task(self.connection.start())
# guest users are rather limited on ICC (helper connection is useless)
if self.host not in ("localhost", "127.0.0.1", "chessclub.com"):
self.helperconn = FICSHelperConnection(self.connection, self.host, ports, timeseal)
self.helperconn.connect("error", self.onHelperConnectionError)
@asyncio.coroutine
def coro():
yield from self.main_connected_event.wait()
yield from self.helperconn.start()
self.helperconn_task = create_task(coro())
def onKibitzMessage(self, cm, name, gameno, text):
@asyncio.coroutine
def coro():
if not self.gmwidg_ready.is_set():
yield from self.gmwidg_ready.wait()
if gameno != self.ficsgame.gameno:
return
self.emit("message_received", name, text)
self.kibitz_task = create_task(coro())
def start_lesson_game(gamemodel, filename, chessfile, records, index, rec):
gamemodel.set_learn_data(LESSON, filename, index, len(records))
# Lichess doesn't export some study data to .pgn like
# Orientation, Analysis mode, Chapter pinned comment, move hint comments, general fail comment
if filename.startswith("lichess_study_beta-lichess-practice-checkmating-with-a-knight-and-bishop"):
if index in (4, 6, 8, 9):
gamemodel.tags["Orientation"] = "White"
print(index, '[Orientation "White"]')
color = gamemodel.boards[0].color
player_name = conf.get("firstName")
w_name = player_name if color == WHITE else "PyChess"
b_name = "PyChess" if color == WHITE else player_name
p0 = (LOCAL, Human, (WHITE, w_name), w_name)
p1 = (LOCAL, Human, (BLACK, b_name), b_name)
def learn_success(gamemodel):
gamemodel.scores = {}
chessfile.loadToModel(rec, -1, gamemodel)
progress = lessons_solving_progress[gamemodel.source]
progress[gamemodel.current_index] = 1
lessons_solving_progress[gamemodel.source] = progress
if "FEN" in gamemodel.tags:
create_task(gamemodel.restart_analyzer(HINT))
gamemodel.connect("learn_success", learn_success)
def on_game_started(gamemodel):
perspective.activate_panel("annotationPanel")
if "FEN" in gamemodel.tags:
create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn()))
gamemodel.connect("game_started", on_game_started)
gamemodel.status = WAITING_TO_START
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, p0, p1))
def onHelperConnectionError(self, connection, error):
if self.helperconn is not None:
dialog = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO)
dialog.set_markup(_("Guest logins disabled by FICS server"))
text = "PyChess can maintain users status and games list only if it changes\n\
'open', 'gin' and 'availinfo' user variables.\n\
Do you enable to set these variables on?"
dialog.format_secondary_text(text)
response = dialog.run()
dialog.destroy()
self.helperconn.cancel()
self.helperconn.close()
self.helperconn = None
set_user_vars = response == Gtk.ResponseType.YES
@asyncio.coroutine
def coro():
yield from self.main_connected_event.wait()
self.connection.start_helper_manager(set_user_vars)
create_task(coro())
def createRematch(gamemodel):
""" If gamemodel contains only LOCAL or ARTIFICIAL players, this starts a
new game, based on the info in gamemodel """
if gamemodel.timed:
secs = gamemodel.timemodel.intervals[0][WHITE]
gain = gamemodel.timemodel.gain
moves = gamemodel.timemodel.moves
else:
secs = 0
gain = 0
moves = 0
newgamemodel = GameModel(TimeModel(secs, gain), variant=gamemodel.variant)
wp = gamemodel.players[WHITE]
bp = gamemodel.players[BLACK]
if wp.__type__ == LOCAL:
player1tup = (wp.__type__, wp.__class__, (BLACK, repr(wp)), repr(wp))
if bp.__type__ == LOCAL:
player0tup = (bp.__type__, bp.__class__,
(WHITE, repr(wp)), repr(bp))
else:
engine = discoverer.getEngineByMd5(bp.md5)
player0tup = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, WHITE, bp.strength, gamemodel.variant, secs,
gain, moves), repr(bp))
else:
player0tup = (bp.__type__, bp.__class__, (WHITE, repr(bp)), repr(bp))
engine = discoverer.getEngineByMd5(wp.md5)
player1tup = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, BLACK, wp.strength, gamemodel.variant, secs,
gain), repr(wp))
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(newgamemodel, player0tup, player1tup))
def row_activated(self, widget, path, col):
rec, ply = self.get_record(path)
if rec is None:
return
self.gamemodel = GameModel()
variant = rec["Variant"]
if variant:
self.gamemodel.tags["Variant"] = variant
# Lichess exports study .pgn without White and Black tags
wp = "" if rec["White"] is None else rec["White"]
bp = "" if rec["Black"] is None else rec["Black"]
p0 = (LOCAL, Human, (WHITE, wp), wp)
p1 = (LOCAL, Human, (BLACK, bp), bp)
self.persp.chessfile.loadToModel(rec, -1, self.gamemodel)
self.gamemodel.endstatus = self.gamemodel.status if self.gamemodel.status in UNDOABLE_STATES else None
self.gamemodel.status = WAITING_TO_START
perspective_manager.activate_perspective("games")
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(self.gamemodel, p0, p1))
def onGamePreview(self, adm, ficsgame):
log.debug("Archived panel onGamePreview: %s" % ficsgame)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
# The players need to start listening for moves IN this method if they
# want to be noticed of all moves the FICS server sends us from now on.
# Hence the lazy loading is skipped.
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
player0tup = (REMOTE, ICPlayer, (
gamemodel, wplayer.name, -1, WHITE,
wplayer.long_name(), wplayer.getRatingByGameType(ficsgame.game_type)),
wplayer.long_name())
player1tup = (REMOTE, ICPlayer, (
gamemodel, bplayer.name, -1, BLACK,
bplayer.long_name(), bplayer.getRatingByGameType(ficsgame.game_type)),
bplayer.long_name())
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, player0tup, player1tup, (
StringIO(ficsgame.board.pgn), pgn, 0, -1)))
gamemodel.connect("game_started", self.on_game_start, ficsgame)
def onObserveGameCreated(self, bm, ficsgame):
log.debug("FICS.onObserveGameCreated: %s" % ficsgame)
timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc)
gamemodel = ICGameModel(self.connection, ficsgame, timemodel)
gamemodel.connect("game_started", self.onGameModelStarted, ficsgame)
# The players need to start listening for moves IN this method if they
# want to be noticed of all moves the FICS server sends us from now on
wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer
player0tup = (REMOTE, ICPlayer, (
gamemodel, wplayer.name, ficsgame.gameno, WHITE,
wplayer.long_name(), wplayer.getRatingForCurrentGame()),
wplayer.long_name())
player1tup = (REMOTE, ICPlayer, (
gamemodel, bplayer.name, ficsgame.gameno, BLACK,
bplayer.long_name(), bplayer.getRatingForCurrentGame()),
bplayer.long_name())
perspective = perspective_manager.get_perspective("games")
create_task(perspective.generalStart(gamemodel, player0tup, player1tup, (
StringIO(ficsgame.board.pgn), pgn, 0, -1)))
if ficsgame.relation == IC_POS_OBSERVING_EXAMINATION:
if 1: # int(self.connection.lvm.variablesBackup["kibitz"]) == 0:
self.connection.cm.whisper(_(
"You have to set kibitz on to see bot messages here."))
self.connection.fm.finger(bplayer.name)
self.connection.fm.finger(wplayer.name)
elif ficsgame.relation == IC_POS_EXAMINATING:
gamemodel.examined = True
if not self.connection.ICC:
allob = 'allob ' + str(ficsgame.gameno)
gamemodel.connection.client.run_command(allob)
def on_game_started(self, gamemodel, gmwidg):
# offline lectures can reuse same gamemodel/gamewidget
# to show several examples inside the same lecture
if gamemodel.offline_lecture:
gmwidg.clearMessages()
# Rotate to human player
boardview = gmwidg.board.view
if gamemodel.players[1].__type__ == LOCAL:
if gamemodel.players[0].__type__ != LOCAL:
boardview.rotation = math.pi
if isinstance(gamemodel, LearnModel):
if gamemodel.orientation == BLACK:
boardview.rotation = math.pi
else:
boardview.rotation = 0
# Play set-up sound
preferencesDialog.SoundTab.playAction("gameIsSetup")
# Connect player offers to infobar
for player in gamemodel.players:
if player.__type__ == LOCAL:
self.offer_cids[gamemodel][player] = player.connect(
"offer", self.offer_callback, gamemodel, gmwidg)
# Start analyzers if any
if not gamemodel.isEngine2EngineGame():
create_task(gamemodel.start_analyzer(HINT))
create_task(gamemodel.start_analyzer(SPY))
if not conf.get("hint_mode"):
gamemodel.pause_analyzer(HINT)
if not conf.get("spy_mode"):
gamemodel.pause_analyzer(SPY)
return False
def setUp(self):
widgets = uistuff.GladeWidgets("PyChess.glade")
gamewidget.setWidgets(widgets)
perspective_manager.set_widgets(widgets)
self.games_persp = Games()
perspective_manager.add_perspective(self.games_persp)
self.learn_persp = Learn()
self.learn_persp.create_toolbuttons()
perspective_manager.add_perspective(self.learn_persp)
perspective_manager.current_perspective = self.learn_persp
dd = DiscovererDialog(discoverer)
self.dd_task = create_task(dd.start())
