pychess package

Subpackages

• pychess.Database package
  • Submodules
  • pychess.Database.JvR module
  • pychess.Database.PgnImport module
    • PgnImport
      • PgnImport.do_cancel()
      • PgnImport.do_import()
      • PgnImport.get_id()
      • PgnImport.ini_names()
      • PgnImport.initialize()
    • read_games()
  • pychess.Database.dbwalk module
    • walk()
  • pychess.Database.model module
    • create_indexes()
    • drop_indexes()
    • get_engine()
    • get_schema_version()
    • ini_schema_version()
    • insert_or_ignore()
  • Module contents
• pychess.Players package
  • Submodules
  • pychess.Players.CECPEngine module
    • CECPEngine
      • CECPEngine.canAnalyze()
      • CECPEngine.end()
      • CECPEngine.getAnalysisLines()
      • CECPEngine.hurry()
      • CECPEngine.kill()
      • CECPEngine.makeMove()
      • CECPEngine.maxAnalysisLines()
      • CECPEngine.minAnalysisLines()
      • CECPEngine.offer()
      • CECPEngine.offerError()
      • CECPEngine.parseLine()
      • CECPEngine.pause()
      • CECPEngine.playerUndoMoves()
      • CECPEngine.prestart()
      • CECPEngine.putMove()
      • CECPEngine.requestMultiPV()
      • CECPEngine.resume()
      • CECPEngine.setBoard()
      • CECPEngine.setBoardList()
      • CECPEngine.setOption()
      • CECPEngine.setOptionAnalyzing()
      • CECPEngine.setOptionInitialBoard()
      • CECPEngine.setOptionStrength()
      • CECPEngine.setOptionTime()
      • CECPEngine.setOptionVariant()
      • CECPEngine.set_board()
      • CECPEngine.spectatorUndoMoves()
      • CECPEngine.start()
      • CECPEngine.updateTime()
  • pychess.Players.Engine module
    • Engine
      • Engine.canAnalyze()
      • Engine.getAnalysis()
      • Engine.maxAnalysisLines()
      • Engine.minAnalysisLines()
      • Engine.offer()
      • Engine.offerDeclined()
      • Engine.offerError()
      • Engine.offerWithdrawn()
      • Engine.on_analysis()
      • Engine.putMessage()
      • Engine.requestMultiPV()
      • Engine.setOptionAnalyzing()
      • Engine.setOptionInitialBoard()
      • Engine.setOptionStrength()
      • Engine.setOptionTime()
      • Engine.setOptionVariant()
  • pychess.Players.Human module
    • Human
      • Human.emit_action()
      • Human.end()
      • Human.hurry()
      • Human.kill()
      • Human.makeMove()
      • Human.offer()
      • Human.offerDeclined()
      • Human.offerError()
      • Human.offerWithdrawn()
      • Human.on_game_terminated()
      • Human.pause()
      • Human.piece_moved()
      • Human.playerUndoMoves()
      • Human.putMessage()
      • Human.resume()
      • Human.sendMessage()
      • Human.zero_reached()
  • pychess.Players.ICPlayer module
    • ICPlayer
      • ICPlayer.end()
      • ICPlayer.getICHandle()
      • ICPlayer.kill()
      • ICPlayer.makeMove()
      • ICPlayer.observe()
      • ICPlayer.offer()
      • ICPlayer.offerDeclined()
      • ICPlayer.offerError()
      • ICPlayer.offerRematch()
      • ICPlayer.offerWithdrawn()
      • ICPlayer.on_game_terminated()
      • ICPlayer.pause()
      • ICPlayer.playerUndoMoves()
      • ICPlayer.putMessage()
      • ICPlayer.resetPosition()
      • ICPlayer.resume()
      • ICPlayer.setBoard()
      • ICPlayer.move_queue
      • ICPlayer.time
  • pychess.Players.Player module
    • GameEnded
    • InvalidMove
    • PassInterrupt
    • PlayerIsDead
    • TurnInterrupt
    • Player
      • Player.end()
      • Player.hurry()
      • Player.kill()
      • Player.makeMove()
      • Player.offer()
      • Player.offerDeclined()
      • Player.offerError()
      • Player.offerWithdrawn()
      • Player.pause()
      • Player.playerUndoMoves()
      • Player.prestart()
      • Player.putMessage()
      • Player.putMove()
      • Player.resume()
      • Player.setName()
      • Player.setOptionInitialBoard()
      • Player.spectatorUndoMoves()
      • Player.start()
      • Player.undoMoves()
      • Player.updateTime()
      • Player.time
  • pychess.Players.ProtocolEngine module
    • ProtocolEngine
      • ProtocolEngine.isAnalyzing()
  • pychess.Players.PyChess module
    • PyChess
      • PyChess.print()
  • pychess.Players.PyChessCECP module
    • PyChessCECP
      • PyChessCECP.handle_sigterm()
      • PyChessCECP.makeReady()
      • PyChessCECP.run()
    • get_input()
  • pychess.Players.PyChessFICS module
    • PyChessFICS
      • PyChessFICS.extendlog()
      • PyChessFICS.main()
      • PyChessFICS.makeReady()
      • PyChessFICS.phoneHome()
      • PyChessFICS.run()
      • PyChessFICS.sendChallenges()
      • PyChessFICS.tellHome()
  • pychess.Players.UCIEngine module
    • UCIEngine
      • UCIEngine.end()
      • UCIEngine.getAnalysisLines()
      • UCIEngine.hasOption()
      • UCIEngine.hurry()
      • UCIEngine.kill()
      • UCIEngine.makeMove()
      • UCIEngine.maxAnalysisLines()
      • UCIEngine.minAnalysisLines()
      • UCIEngine.offer()
      • UCIEngine.parseLine()
      • UCIEngine.pause()
      • UCIEngine.playerUndoMoves()
      • UCIEngine.prestart()
      • UCIEngine.putMove()
      • UCIEngine.requestMultiPV()
      • UCIEngine.resume()
      • UCIEngine.setBoard()
      • UCIEngine.setOption()
      • UCIEngine.setOptionAnalyzing()
      • UCIEngine.setOptionInitialBoard()
      • UCIEngine.setOptionStrength()
      • UCIEngine.setOptionTime()
      • UCIEngine.setOptionVariant()
      • UCIEngine.set_board()
      • UCIEngine.spectatorUndoMoves()
      • UCIEngine.start()
      • UCIEngine.updateTime()
  • pychess.Players.engineNest module
    • SubProcessError
    • EngineDiscoverer
      • EngineDiscoverer.addEngine()
      • EngineDiscoverer.addEngineFromReference()
      • EngineDiscoverer.backup()
      • EngineDiscoverer.discover()
      • EngineDiscoverer.getAnalyzers()
      • EngineDiscoverer.getCountry()
      • EngineDiscoverer.getEngineByMd5()
      • EngineDiscoverer.getEngineByName()
      • EngineDiscoverer.getEngineLearn()
      • EngineDiscoverer.getEngineN()
      • EngineDiscoverer.getEngineVariants()
      • EngineDiscoverer.getEngines()
      • EngineDiscoverer.getName()
      • EngineDiscoverer.getReferencedEngine()
      • EngineDiscoverer.hasChanged()
      • EngineDiscoverer.initAnalyzerEngine()
      • EngineDiscoverer.initEngine()
      • EngineDiscoverer.initPlayerEngine()
      • EngineDiscoverer.is_analyzer()
      • EngineDiscoverer.pre_discover()
      • EngineDiscoverer.removeEngine()
      • EngineDiscoverer.restore()
      • EngineDiscoverer.save()
    • init_engine()
    • is_cecp()
    • is_uci()
    • md5_sum()
  • Module contents
• pychess.Savers package
  • Submodules
  • pychess.Savers.ChessFile module
    • LoadingError
    • ChessFile
      • ChessFile.close()
      • ChessFile.get_book_moves()
      • ChessFile.get_date()
      • ChessFile.get_elo()
      • ChessFile.get_event()
      • ChessFile.get_id()
      • ChessFile.get_info()
      • ChessFile.get_player_names()
      • ChessFile.get_records()
      • ChessFile.get_result()
      • ChessFile.get_round()
      • ChessFile.get_site()
      • ChessFile.get_variant()
      • ChessFile.loadToModel()
      • ChessFile.set_fen_filter()
      • ChessFile.set_scout_filter()
      • ChessFile.set_tags_filter()
  • pychess.Savers.chessalpha2 module
  • pychess.Savers.chesspastebin module
    • paste()
  • pychess.Savers.database module
    • TagDatabase
      • TagDatabase.build_order_by()
      • TagDatabase.build_query()
      • TagDatabase.build_where_offs()
      • TagDatabase.build_where_offs8()
      • TagDatabase.build_where_tags()
      • TagDatabase.close()
      • TagDatabase.get_exta_tags()
      • TagDatabase.get_info()
      • TagDatabase.get_offsets_for_tags()
      • TagDatabase.get_records()
      • TagDatabase.count
    • parseDateTag()
    • save()
  • pychess.Savers.epd module
    • EpdFile
      • EpdFile.create_rec()
      • EpdFile.get_player_names()
      • EpdFile.loadToModel()
    • load()
    • save()
  • pychess.Savers.fen module
    • FenFile
      • FenFile.loadToModel()
    • load()
    • save()
  • pychess.Savers.pgn module
    • PGNFile
      • PGNFile.close()
      • PGNFile.get_book_moves()
      • PGNFile.get_count()
      • PGNFile.get_movetext()
      • PGNFile.get_offs()
      • PGNFile.get_offs8()
      • PGNFile.get_records()
      • PGNFile.get_size()
      • PGNFile.get_variant()
      • PGNFile.has_position()
      • PGNFile.init_chess_db()
      • PGNFile.init_scoutfish()
      • PGNFile.init_tag_database()
      • PGNFile.loadToModel()
      • PGNFile.load_game_tags()
      • PGNFile.parse_movetext()
      • PGNFile.reset_last_seen()
      • PGNFile.set_fen_filter()
      • PGNFile.set_scout_filter()
      • PGNFile.set_tag_filter()
      • PGNFile.set_tag_order()
      • PGNFile.count
      • PGNFile.size
    • load()
    • move_count()
    • msToClockTimeTag()
    • nag2symbol()
    • parseClockTimeTag()
    • parseTimeControlTag()
    • save()
    • symbol2nag()
    • walk()
  • pychess.Savers.png module
    • save()
  • Module contents
• pychess.System package
  • Submodules
  • pychess.System.Log module
    • ExtraAdapter
      • ExtraAdapter.process()
    • LoggerWriter
      • LoggerWriter.flush()
      • LoggerWriter.write()
    • TaskFormatter
      • TaskFormatter.format()
    • setup_glib_logging()
  • pychess.System.LogEmitter module
    • GLogHandler
      • GLogHandler.emit()
    • LogEmitter
  • pychess.System.SubProcess module
    • SubProcess
      • SubProcess.pause()
      • SubProcess.read_stdout()
      • SubProcess.resume()
      • SubProcess.start()
      • SubProcess.terminate()
      • SubProcess.write()
      • SubProcess.write_stdin()
  • pychess.System.accordion module
  • pychess.System.cairoextras module
  • pychess.System.command module
    • Command
      • Command.run()
  • pychess.System.conf module
    • get()
    • hasKey()
    • notify_add()
    • notify_remove()
    • save_config()
    • set()
  • pychess.System.debug module
    • obj_referrers()
    • print_muppy_sumary()
    • print_obj_referrers()
  • pychess.System.gst_player module
    • on_message()
    • play()
  • pychess.System.gstreamer module
    • GstPlayer
      • GstPlayer.play()
    • Player
      • Player.play()
  • pychess.System.ping module
    • Pinger
      • Pinger.start()
      • Pinger.stop()
  • pychess.System.prefix module
    • addDataPrefix()
    • addEngineDataPrefix()
    • addUserCachePrefix()
    • addUserConfigPrefix()
    • addUserDataPrefix()
    • getDataPrefix()
    • getEngineDataPrefix()
    • getUserCachePrefix()
    • getUserConfigPrefix()
    • getUserDataPrefix()
    • get_user_cache_dir()
    • get_user_config_dir()
    • get_user_data_dir()
    • isInstalled()
  • pychess.System.protoopen module
    • isWriteable()
    • protoopen()
    • protosave()
    • splitUri()
  • pychess.System.readuntil module
    • IncompleteReadError
    • LimitOverrunError
    • readuntil()
  • pychess.System.repeat module
    • repeat()
    • repeat_sleep()
  • pychess.System.uistuff module
    • GladeWidgets
      • GladeWidgets.getGlade()
    • appendAutowrapColumn()
    • createCombo()
    • genColor()
    • getMonitorBounds()
    • keep()
    • keepDown()
    • keepWindowSize()
    • loadDialogWidget()
    • makeYellow()
    • onceWhenReady()
    • saveDialogWidget()
    • updateCombo()
  • Module contents
    • Timer
    • caller_name()
    • download_file()
    • download_file_async()
    • fident()
    • get_threadname()
    • profile_me()
• pychess.Utils package
  • Subpackages
    • pychess.Utils.lutils package
      • Submodules
      • pychess.Utils.lutils.Benchmark module
        • benchmark()
      • pychess.Utils.lutils.LBoard module
        • LBoard
          • LBoard.applyFen()
          • LBoard.applyMove()
          • LBoard.asFen()
          • LBoard.clone()
          • LBoard.iniAtomic()
          • LBoard.iniCambodian()
          • LBoard.iniHouse()
          • LBoard.iniSchess()
          • LBoard.isChecked()
          • LBoard.opIsChecked()
          • LBoard.popMove()
          • LBoard.prepr()
          • LBoard.repetitionCount()
          • LBoard.reprCastling()
          • LBoard.setCastling()
          • LBoard.setColor()
          • LBoard.setEnpassant()
          • LBoard.willGiveCheck()
          • LBoard.willLeaveInCheck()
          • LBoard.fin_kings
          • LBoard.fin_rooks
          • LBoard.holding
          • LBoard.ini_kings
          • LBoard.ini_rooks
          • LBoard.lastMove
      • pychess.Utils.lutils.PolyglotHash module
      • pychess.Utils.lutils.TranspositionTable module
        • TranspositionTable
          • TranspositionTable.addButterfly()
          • TranspositionTable.addKiller()
          • TranspositionTable.clear()
          • TranspositionTable.getButterfly()
          • TranspositionTable.isHashMove()
          • TranspositionTable.isKiller()
          • TranspositionTable.newSearch()
          • TranspositionTable.probe()
          • TranspositionTable.record()
          • TranspositionTable.setHashMove()
      • pychess.Utils.lutils.attack module
        • addXrayPiece()
        • defends()
        • getAttacks()
        • isAttacked()
        • piecesAttackingCord()
        • pinnedOnKing()
        • propagateRayFollowingMovement()
        • staticExchangeEvaluate()
      • pychess.Utils.lutils.bitboard module
        • clearBit()
        • firstBit()
        • iterBits()
        • lastBit()
        • setBit()
        • toString()
      • pychess.Utils.lutils.egtb_gaviota module
        • EgtbGaviota
          • EgtbGaviota.scoreAllMoves()
          • EgtbGaviota.scoreGame()
          • EgtbGaviota.supports()
        • TbStats
          • TbStats.bytes_read
          • TbStats.drive_hits
          • TbStats.drive_miss
          • TbStats.dtm_cachesize
          • TbStats.dtm_easy_hits
          • TbStats.dtm_hard_prob
          • TbStats.dtm_occupancy
          • TbStats.dtm_soft_prob
          • TbStats.files_opened
          • TbStats.memory_efficiency
          • TbStats.memory_hits
          • TbStats.total_hits
          • TbStats.wdl_cachesize
          • TbStats.wdl_easy_hits
          • TbStats.wdl_hard_prob
          • TbStats.wdl_occupancy
          • TbStats.wdl_soft_prob
      • pychess.Utils.lutils.egtb_k4it module
        • EgtbK4kit
          • EgtbK4kit.scoreAllMoves()
          • EgtbK4kit.scoreGame()
          • EgtbK4kit.supports()
      • pychess.Utils.lutils.ldata module
        • FILE()
        • RANK()
        • VALUE_AT_PLY()
      • pychess.Utils.lutils.ldraw module
        • test()
        • testFifty()
        • testMaterial()
        • testPlayerMatingMaterial()
      • pychess.Utils.lutils.leval module
        • cacheablePawnInfo()
        • clearPawnTable()
        • evalBishops()
        • evalDev()
        • evalDoubleQR7()
        • evalKing()
        • evalKingTropism()
        • evalMaterial()
        • evalPawnStructure()
        • evalRooks()
        • evalTrappedBishops()
        • evaluateComplete()
        • probePawns()
        • recordPawns()
      • pychess.Utils.lutils.lmove module
        • ParsingError
        • FCORD()
        • FILE()
        • FLAG()
        • FLAG_PIECE()
        • GATE_PIECE()
        • PROMOTE_PIECE()
        • RANK()
        • TCORD()
        • determineAlgebraicNotation()
        • listToMoves()
        • listToSan()
        • parseAN()
        • parseAny()
        • parseFAN()
        • parseLAN()
        • parsePolyglot()
        • parseSAN()
        • sittuyin_promotion_fcord()
        • toAN()
        • toFAN()
        • toLAN()
        • toPolyglot()
        • toSAN()
      • pychess.Utils.lutils.lmovegen module
        • genAllMoves()
        • genCaptures()
        • genCastles()
        • genCheckEvasions()
        • genDrops()
        • genPieceMoves()
        • gen_sittuyin_promotions()
        • newMove()
      • pychess.Utils.lutils.lsearch module
        • EndgameTable
          • EndgameTable.scoreAllMoves()
        • alphaBeta()
        • enableEGTB()
        • quiescent()
        • random()
      • pychess.Utils.lutils.lsort module
        • getCaptureValue()
        • getMoveValue()
        • sortCaptures()
        • sortMoves()
      • pychess.Utils.lutils.perft module
        • do_perft()
        • perft()
      • pychess.Utils.lutils.strateval module
        • attack_type()
        • defencive_moves_safety()
        • defencive_moves_tactic()
        • final_status()
        • join()
        • offencive_moves_check()
        • offencive_moves_fianchetto()
        • offencive_moves_pin()
        • offencive_moves_rook()
        • prefix_type()
        • simple_activity()
        • simple_tropism()
        • state_destroysCastling()
        • state_outpost()
        • state_pawn()
        • state_trappedBishops()
        • tip_mobility()
        • tip_pawnStorm()
      • pychess.Utils.lutils.validator module
        • validateMove()
      • Module contents
  • Submodules
  • pychess.Utils.Board module
    • Board
      • Board.asFen()
      • Board.clone()
      • Board.getHoldingCord()
      • Board.getHoldingPieces()
      • Board.move()
      • Board.newHoldingCord()
      • Board.popPieceFromHolding()
      • Board.printPieces()
      • Board.reorderHolding()
      • Board.setColor()
      • Board.simulateMove()
      • Board.simulateUnmove()
      • Board.switchColor()
      • Board.FILES
      • Board.HOLDING_FILES
      • Board.PROMOTIONS
      • Board.PROMOTION_ZONE
      • Board.RANKS
      • Board.color
      • Board.enpassant
      • Board.ply
      • Board.variant
    • reverse_enum()
  • pychess.Utils.Cord module
    • CordFormatException
    • Cord
      • Cord.charToInt()
      • Cord.intToChar()
      • Cord.cord
      • Cord.cords
      • Cord.cx
      • Cord.cy
    • cmp()
  • pychess.Utils.EndgameTable module
    • EndgameTable
      • EndgameTable.scoreAllMoves()
      • EndgameTable.scoreGame()
  • pychess.Utils.GameModel module
    • GameModel
      • GameModel.acceptReceived()
      • GameModel.add_move2variation()
      • GameModel.add_variation()
      • GameModel.checkStatus()
      • GameModel.color()
      • GameModel.declineReceived()
      • GameModel.end()
      • GameModel.getBoardAtPly()
      • GameModel.getMoveAtPly()
      • GameModel.get_book_move()
      • GameModel.hasEnginePlayer()
      • GameModel.hasLocalPlayer()
      • GameModel.isChanged()
      • GameModel.isEngine2EngineGame()
      • GameModel.isLoadedGame()
      • GameModel.isLocalGame()
      • GameModel.isObservationGame()
      • GameModel.isPlayingICSGame()
      • GameModel.kill()
      • GameModel.loadAndStart()
      • GameModel.offerReceived()
      • GameModel.on_analyze()
      • GameModel.pause()
      • GameModel.pause_analyzer()
      • GameModel.remove_analyzer()
      • GameModel.remove_variation()
      • GameModel.restart_analyzer()
      • GameModel.resume()
      • GameModel.resume_analyzer()
      • GameModel.save()
      • GameModel.setOpening()
      • GameModel.setPlayers()
      • GameModel.start()
      • GameModel.start_analyzer()
      • GameModel.terminate()
      • GameModel.undoMoves()
      • GameModel.undo_in_variation()
      • GameModel.withdrawReceived()
      • GameModel.zero_reached()
      • GameModel.curplayer
      • GameModel.display_text
      • GameModel.lowply
      • GameModel.orientation
      • GameModel.ply
      • GameModel.practice_game
      • GameModel.starting_color
      • GameModel.waitingplayer
  • pychess.Utils.IconLoader module
    • get_pixbuf()
    • load_icon()
  • pychess.Utils.Move module
    • Move
      • Move.as_uci()
      • Move.is_capture()
      • Move.cords
      • Move.promotion
    • listToMoves()
    • listToSan()
    • parseAN()
    • parseAny()
    • parseFAN()
    • parseLAN()
    • parseSAN()
    • toAN()
    • toFAN()
    • toLAN()
    • toSAN()
  • pychess.Utils.Offer module
    • Offer
    • cmp()
  • pychess.Utils.Piece module
    • Piece
      • Piece.sign
  • pychess.Utils.SetupModel module
    • SetupModel
      • SetupModel.getBoardAtPly()
      • SetupModel.getMoveAtPly()
      • SetupModel.isPlayingICSGame()
      • SetupModel.receiveSupportAlgorithm()
      • SetupModel.start()
      • SetupModel.ply
    • SetupMove
      • SetupMove.is_capture()
    • SetupPlayer
      • SetupPlayer.make_move()
      • SetupPlayer.on_action()
      • SetupPlayer.piece_moved()
  • pychess.Utils.TimeModel module
    • TimeModel
      • TimeModel.end()
      • TimeModel.getElapsedMoveTime()
      • TimeModel.getInitialTime()
      • TimeModel.getPlayerTime()
      • TimeModel.hasBWTimes()
      • TimeModel.isBlitzFide()
      • TimeModel.pause()
      • TimeModel.resume()
      • TimeModel.setMovingColor()
      • TimeModel.start()
      • TimeModel.tap()
      • TimeModel.undoMoves()
      • TimeModel.updatePlayer()
      • TimeModel.display_text
      • TimeModel.hasTimes
      • TimeModel.ply
  • pychess.Utils.book module
    • BookEntry
      • BookEntry.key
      • BookEntry.learn
      • BookEntry.move
      • BookEntry.weight
    • getOpenings()
  • pychess.Utils.checkversion module
    • checkversion()
    • isgit()
  • pychess.Utils.const module
  • pychess.Utils.eco module
    • find_opening_fen()
    • get_eco()
  • pychess.Utils.elo module
    • get_elo_rating_change()
    • get_elo_rating_change_pgn()
    • get_elo_rating_change_str()
  • pychess.Utils.eval module
    • analyzePawnStructure()
    • evalBadBishops()
    • evalCastling()
    • evalDevelopment()
    • evalKingTropism()
    • evalMaterial()
    • evalPawnStructure()
    • evalRookBonus()
    • evaluateComplete()
    • lookUpTropism()
  • pychess.Utils.isoCountries module
    • ISO3166
      • ISO3166.country
      • ISO3166.iso2
  • pychess.Utils.logic module
    • genCastles()
    • getDestinationCords()
    • getMoveKillingKing()
    • getStatus()
    • isClaimableDraw()
    • legalMoveCount()
    • playerHasMatingMaterial()
    • standard_validate()
    • validate()
  • pychess.Utils.repr module
  • Module contents
    • wait_signal
      • wait_signal.cancel()
    • createStoryTextAppEvent()
    • formatTime()
    • prettyPrintScore()
• pychess.Variants package
  • Submodules
  • pychess.Variants.asean module
    • AiWokBoard
      • AiWokBoard.PROMOTIONS
      • AiWokBoard.PROMOTION_ZONE
      • AiWokBoard.cecp_name
      • AiWokBoard.name
      • AiWokBoard.need_initial_board
      • AiWokBoard.standard_rules
      • AiWokBoard.variant
      • AiWokBoard.variant_group
    • AseanBoard
      • AseanBoard.cecp_name
      • AseanBoard.name
      • AseanBoard.need_initial_board
      • AseanBoard.standard_rules
      • AseanBoard.variant
      • AseanBoard.variant_group
    • CambodianBoard
      • CambodianBoard.PROMOTIONS
      • CambodianBoard.PROMOTION_ZONE
      • CambodianBoard.cecp_name
      • CambodianBoard.name
      • CambodianBoard.need_initial_board
      • CambodianBoard.standard_rules
      • CambodianBoard.variant
      • CambodianBoard.variant_group
    • MakrukBoard
      • MakrukBoard.PROMOTIONS
      • MakrukBoard.PROMOTION_ZONE
      • MakrukBoard.cecp_name
      • MakrukBoard.name
      • MakrukBoard.need_initial_board
      • MakrukBoard.standard_rules
      • MakrukBoard.variant
      • MakrukBoard.variant_group
    • SittuyinBoard
      • SittuyinBoard.PROMOTIONS
      • SittuyinBoard.PROMOTION_ZONE
      • SittuyinBoard.cecp_name
      • SittuyinBoard.name
      • SittuyinBoard.need_initial_board
      • SittuyinBoard.standard_rules
      • SittuyinBoard.variant
      • SittuyinBoard.variant_group
  • pychess.Variants.asymmetricrandom module
    • AsymmetricRandomBoard
      • AsymmetricRandomBoard.asymmetricrandom_start()
      • AsymmetricRandomBoard.cecp_name
      • AsymmetricRandomBoard.name
      • AsymmetricRandomBoard.need_initial_board
      • AsymmetricRandomBoard.standard_rules
      • AsymmetricRandomBoard.variant
      • AsymmetricRandomBoard.variant_group
  • pychess.Variants.atomic module
    • AtomicBoard
      • AtomicBoard.cecp_name
      • AtomicBoard.name
      • AtomicBoard.need_initial_board
      • AtomicBoard.standard_rules
      • AtomicBoard.variant
      • AtomicBoard.variant_group
    • cordsAround()
    • kingExplode()
    • piecesAround()
  • pychess.Variants.blindfold module
    • AllPawnsBoard
      • AllPawnsBoard.cecp_name
      • AllPawnsBoard.name
      • AllPawnsBoard.need_initial_board
      • AllPawnsBoard.standard_rules
      • AllPawnsBoard.variant
      • AllPawnsBoard.variant_group
    • AllWhiteBoard
      • AllWhiteBoard.cecp_name
      • AllWhiteBoard.name
      • AllWhiteBoard.need_initial_board
      • AllWhiteBoard.standard_rules
      • AllWhiteBoard.variant
      • AllWhiteBoard.variant_group
    • AllWhitePawnsBoard
      • AllWhitePawnsBoard.cecp_name
      • AllWhitePawnsBoard.name
      • AllWhitePawnsBoard.need_initial_board
      • AllWhitePawnsBoard.standard_rules
      • AllWhitePawnsBoard.variant
      • AllWhitePawnsBoard.variant_group
    • BlindfoldBoard
      • BlindfoldBoard.cecp_name
      • BlindfoldBoard.name
      • BlindfoldBoard.need_initial_board
      • BlindfoldBoard.standard_rules
      • BlindfoldBoard.variant
      • BlindfoldBoard.variant_group
    • HiddenPawnsBoard
      • HiddenPawnsBoard.cecp_name
      • HiddenPawnsBoard.name
      • HiddenPawnsBoard.need_initial_board
      • HiddenPawnsBoard.standard_rules
      • HiddenPawnsBoard.variant
      • HiddenPawnsBoard.variant_group
    • HiddenPiecesBoard
      • HiddenPiecesBoard.cecp_name
      • HiddenPiecesBoard.name
      • HiddenPiecesBoard.need_initial_board
      • HiddenPiecesBoard.standard_rules
      • HiddenPiecesBoard.variant
      • HiddenPiecesBoard.variant_group
  • pychess.Variants.bughouse module
    • BughouseBoard
      • BughouseBoard.cecp_name
      • BughouseBoard.name
      • BughouseBoard.need_initial_board
      • BughouseBoard.standard_rules
      • BughouseBoard.variant
      • BughouseBoard.variant_group
  • pychess.Variants.corner module
    • CornerBoard
      • CornerBoard.shuffle_start()
      • CornerBoard.cecp_name
      • CornerBoard.name
      • CornerBoard.need_initial_board
      • CornerBoard.standard_rules
      • CornerBoard.variant
      • CornerBoard.variant_group
  • pychess.Variants.crazyhouse module
    • CrazyhouseBoard
      • CrazyhouseBoard.cecp_name
      • CrazyhouseBoard.name
      • CrazyhouseBoard.need_initial_board
      • CrazyhouseBoard.standard_rules
      • CrazyhouseBoard.variant
      • CrazyhouseBoard.variant_group
  • pychess.Variants.euroshogi module
    • EuroShogiBoard
      • EuroShogiBoard.PROMOTION_ZONE
      • EuroShogiBoard.cecp_name
      • EuroShogiBoard.name
      • EuroShogiBoard.need_initial_board
      • EuroShogiBoard.standard_rules
      • EuroShogiBoard.variant
      • EuroShogiBoard.variant_group
  • pychess.Variants.fischerandom module
    • FischerandomBoard
      • FischerandomBoard.getFrcFen()
      • FischerandomBoard.shuffle_start()
      • FischerandomBoard.cecp_name
      • FischerandomBoard.name
      • FischerandomBoard.need_initial_board
      • FischerandomBoard.standard_rules
      • FischerandomBoard.variant
      • FischerandomBoard.variant_group
  • pychess.Variants.giveaway module
    • GiveawayBoard
      • GiveawayBoard.cecp_name
      • GiveawayBoard.name
      • GiveawayBoard.variant
  • pychess.Variants.horde module
    • HordeBoard
      • HordeBoard.FILES
      • HordeBoard.HOLDING_FILES
      • HordeBoard.cecp_name
      • HordeBoard.name
      • HordeBoard.need_initial_board
      • HordeBoard.standard_rules
      • HordeBoard.variant
      • HordeBoard.variant_group
  • pychess.Variants.kingofthehill module
    • KingOfTheHillBoard
      • KingOfTheHillBoard.cecp_name
      • KingOfTheHillBoard.name
      • KingOfTheHillBoard.need_initial_board
      • KingOfTheHillBoard.standard_rules
      • KingOfTheHillBoard.variant
      • KingOfTheHillBoard.variant_group
    • testKingInCenter()
  • pychess.Variants.knightodds module
    • KnightOddsBoard
      • KnightOddsBoard.cecp_name
      • KnightOddsBoard.name
      • KnightOddsBoard.need_initial_board
      • KnightOddsBoard.standard_rules
      • KnightOddsBoard.variant
      • KnightOddsBoard.variant_group
  • pychess.Variants.losers module
    • LosersBoard
      • LosersBoard.cecp_name
      • LosersBoard.name
      • LosersBoard.need_initial_board
      • LosersBoard.standard_rules
      • LosersBoard.variant
      • LosersBoard.variant_group
    • testKingOnly()
  • pychess.Variants.normal module
    • NormalBoard
      • NormalBoard.cecp_name
      • NormalBoard.name
      • NormalBoard.need_initial_board
      • NormalBoard.standard_rules
  • pychess.Variants.pawnodds module
    • PawnOddsBoard
      • PawnOddsBoard.cecp_name
      • PawnOddsBoard.name
      • PawnOddsBoard.need_initial_board
      • PawnOddsBoard.standard_rules
      • PawnOddsBoard.variant
      • PawnOddsBoard.variant_group
  • pychess.Variants.pawnspassed module
    • PawnsPassedBoard
      • PawnsPassedBoard.cecp_name
      • PawnsPassedBoard.name
      • PawnsPassedBoard.need_initial_board
      • PawnsPassedBoard.standard_rules
      • PawnsPassedBoard.variant
      • PawnsPassedBoard.variant_group
  • pychess.Variants.pawnspushed module
    • PawnsPushedBoard
      • PawnsPushedBoard.cecp_name
      • PawnsPushedBoard.name
      • PawnsPushedBoard.need_initial_board
      • PawnsPushedBoard.standard_rules
      • PawnsPushedBoard.variant
      • PawnsPushedBoard.variant_group
  • pychess.Variants.queenodds module
    • QueenOddsBoard
      • QueenOddsBoard.cecp_name
      • QueenOddsBoard.name
      • QueenOddsBoard.need_initial_board
      • QueenOddsBoard.standard_rules
      • QueenOddsBoard.variant
      • QueenOddsBoard.variant_group
  • pychess.Variants.racingkings module
    • RacingKingsBoard
      • RacingKingsBoard.cecp_name
      • RacingKingsBoard.name
      • RacingKingsBoard.need_initial_board
      • RacingKingsBoard.standard_rules
      • RacingKingsBoard.variant
      • RacingKingsBoard.variant_group
    • test2KingInEightRow()
    • testKingInEightRow()
  • pychess.Variants.randomchess module
    • RandomBoard
      • RandomBoard.random_start()
      • RandomBoard.cecp_name
      • RandomBoard.name
      • RandomBoard.need_initial_board
      • RandomBoard.standard_rules
      • RandomBoard.variant
      • RandomBoard.variant_group
  • pychess.Variants.rookodds module
    • RookOddsBoard
      • RookOddsBoard.cecp_name
      • RookOddsBoard.name
      • RookOddsBoard.need_initial_board
      • RookOddsBoard.standard_rules
      • RookOddsBoard.variant
      • RookOddsBoard.variant_group
  • pychess.Variants.seirawan module
    • SchessBoard
      • SchessBoard.PROMOTIONS
      • SchessBoard.cecp_name
      • SchessBoard.name
      • SchessBoard.need_initial_board
      • SchessBoard.standard_rules
      • SchessBoard.variant
      • SchessBoard.variant_group
  • pychess.Variants.setupposition module
    • SetupBoard
      • SetupBoard.as_fen()
      • SetupBoard.move()
      • SetupBoard.simulateMove()
      • SetupBoard.PROMOTIONS
      • SetupBoard.PROMOTION_ZONE
      • SetupBoard.cecp_name
      • SetupBoard.name
      • SetupBoard.ply
      • SetupBoard.standard_rules
      • SetupBoard.variant
      • SetupBoard.variant_group
  • pychess.Variants.shuffle module
    • ShuffleBoard
      • ShuffleBoard.shuffle_start()
      • ShuffleBoard.cecp_name
      • ShuffleBoard.name
      • ShuffleBoard.need_initial_board
      • ShuffleBoard.standard_rules
      • ShuffleBoard.variant
      • ShuffleBoard.variant_group
  • pychess.Variants.suicide module
    • SuicideBoard
      • SuicideBoard.PROMOTIONS
      • SuicideBoard.cecp_name
      • SuicideBoard.name
      • SuicideBoard.need_initial_board
      • SuicideBoard.standard_rules
      • SuicideBoard.variant
      • SuicideBoard.variant_group
    • pieceCount()
  • pychess.Variants.theban module
    • ThebanBoard
      • ThebanBoard.cecp_name
      • ThebanBoard.name
      • ThebanBoard.need_initial_board
      • ThebanBoard.standard_rules
      • ThebanBoard.variant
      • ThebanBoard.variant_group
  • pychess.Variants.threecheck module
    • ThreeCheckBoard
      • ThreeCheckBoard.cecp_name
      • ThreeCheckBoard.name
      • ThreeCheckBoard.need_initial_board
      • ThreeCheckBoard.standard_rules
      • ThreeCheckBoard.variant
      • ThreeCheckBoard.variant_group
    • checkCount()
  • pychess.Variants.upsidedown module
    • UpsideDownBoard
      • UpsideDownBoard.cecp_name
      • UpsideDownBoard.name
      • UpsideDownBoard.need_initial_board
      • UpsideDownBoard.standard_rules
      • UpsideDownBoard.variant
      • UpsideDownBoard.variant_group
  • pychess.Variants.wildcastle module
    • WildcastleBoard
      • WildcastleBoard.cecp_name
      • WildcastleBoard.name
      • WildcastleBoard.need_initial_board
      • WildcastleBoard.standard_rules
      • WildcastleBoard.variant
      • WildcastleBoard.variant_group
  • pychess.Variants.wildcastleshuffle module
    • WildcastleShuffleBoard
      • WildcastleShuffleBoard.shuffle_start()
      • WildcastleShuffleBoard.cecp_name
      • WildcastleShuffleBoard.name
      • WildcastleShuffleBoard.need_initial_board
      • WildcastleShuffleBoard.standard_rules
      • WildcastleShuffleBoard.variant
      • WildcastleShuffleBoard.variant_group
  • Module contents
• pychess.gfx package
  • Submodules
  • pychess.gfx.Pieces module
    • drawPiece()
    • get_svg_pieces()
    • set_piece_theme()
  • Module contents
• pychess.ic package
  • Subpackages
    • pychess.ic.managers package
      • Submodules
      • pychess.ic.managers.AdjournManager module
        • AdjournManager
          • AdjournManager.abort()
          • AdjournManager.challenge()
          • AdjournManager.draw()
          • AdjournManager.examine()
          • AdjournManager.queryAdjournments()
          • AdjournManager.queryHistory()
          • AdjournManager.queryJournal()
          • AdjournManager.queryMoves()
          • AdjournManager.resign()
          • AdjournManager.resume()
      • pychess.ic.managers.AutoLogOutManager module
        • AutoLogOutManager
          • AutoLogOutManager.onLogOut()
      • pychess.ic.managers.BoardManager module
        • BoardManager
          • BoardManager.accept()
          • BoardManager.callflag()
          • BoardManager.decline()
          • BoardManager.follow()
          • BoardManager.generateCastleSigns()
          • BoardManager.isPlaying()
          • BoardManager.made_examined()
          • BoardManager.made_unexamined()
          • BoardManager.matchDeclined()
          • BoardManager.nonoWhileExamine()
          • BoardManager.observe()
          • BoardManager.onArchiveGameSMovesReceived()
          • BoardManager.onExamineGameCreated()
          • BoardManager.onGameEnd()
          • BoardManager.onGameModelStarted()
          • BoardManager.onGamePause()
          • BoardManager.onInterceptedChallenge()
          • BoardManager.onMatchingSeekOrGetGame()
          • BoardManager.onObserveGameCreated()
          • BoardManager.onObserveGameMovesReceived()
          • BoardManager.onPlayGameCreated()
          • BoardManager.onStyle12()
          • BoardManager.onUnobserveGame()
          • BoardManager.onWasPrivate()
          • BoardManager.on_game_remove()
          • BoardManager.opp_not_out_of_time()
          • BoardManager.parseGame()
          • BoardManager.parseStyle12()
          • BoardManager.play()
          • BoardManager.player_lagged()
          • BoardManager.player_on_censor()
          • BoardManager.player_on_noplay()
          • BoardManager.req_not_fit_formula()
          • BoardManager.resign()
          • BoardManager.sendMove()
          • BoardManager.start()
          • BoardManager.tooManySeeks()
          • BoardManager.unexamine()
          • BoardManager.unobserve()
          • BoardManager.castleSigns
          • BoardManager.queuedStyle12s
        • parse_reason()
      • pychess.ic.managers.ChatManager module
        • ChatManager
          • ChatManager.convTime()
          • ChatManager.entityDecode()
          • ChatManager.entityEncode()
          • ChatManager.getChannelLog()
          • ChatManager.getChannelPlayers()
          • ChatManager.getChannels()
          • ChatManager.getJoinedChannels()
          • ChatManager.getNoChannelPlayers()
          • ChatManager.getPeopleInChannel()
          • ChatManager.getPlayersChannels()
          • ChatManager.get_allob_list()
          • ChatManager.gotPlayerChannels()
          • ChatManager.joinChannel()
          • ChatManager.mayTellChannel()
          • ChatManager.onAnnouncement()
          • ChatManager.onArrivalNotification()
          • ChatManager.onChannelList()
          • ChatManager.onChannelLogBreak()
          • ChatManager.onChannelLogLine()
          • ChatManager.onChannelLogStart()
          • ChatManager.onChannelMessage()
          • ChatManager.onDepartedNotification()
          • ChatManager.onKibitzMessage()
          • ChatManager.onPrivateMessage()
          • ChatManager.onShoutMessage()
          • ChatManager.onWhisperMessage()
          • ChatManager.on_allob_no()
          • ChatManager.removeChannel()
          • ChatManager.tellAll()
          • ChatManager.tellBughousePartner()
          • ChatManager.tellChannel()
          • ChatManager.tellGame()
          • ChatManager.tellOpponent()
          • ChatManager.tellPlayer()
          • ChatManager.tellUser()
          • ChatManager.toldChannel()
          • ChatManager.whisper()
          • ChatManager.channelListItem
          • ChatManager.entityExpr
      • pychess.ic.managers.ConsoleManager module
        • ConsoleManager
          • ConsoleManager.onConsoleMessage()
      • pychess.ic.managers.ErrorManager module
        • ErrorManager
          • ErrorManager.onAmbiguousMove()
          • ErrorManager.onError()
          • ErrorManager.onIllegalMove()
      • pychess.ic.managers.FingerManager module
        • FingerManager
          • FingerManager.finger()
          • FingerManager.onFinger()
          • FingerManager.onRatingAdjust()
          • FingerManager.parseDate()
          • FingerManager.parseShortDate()
          • FingerManager.parseTime()
          • FingerManager.setBusyMessage()
          • FingerManager.setFingerNote()
        • FingerObject
          • FingerObject.getAdminLevel()
          • FingerObject.getBusyMessage()
          • FingerObject.getColor()
          • FingerObject.getCreated()
          • FingerObject.getEmail()
          • FingerObject.getGameno()
          • FingerObject.getIdleTime()
          • FingerObject.getLastSeen()
          • FingerObject.getName()
          • FingerObject.getNotes()
          • FingerObject.getOpponent()
          • FingerObject.getRating()
          • FingerObject.getRatings()
          • FingerObject.getRatingsLen()
          • FingerObject.getSanctions()
          • FingerObject.getSilence()
          • FingerObject.getStatus()
          • FingerObject.getTimeseal()
          • FingerObject.getTitles()
          • FingerObject.getTotalTimeOnline()
          • FingerObject.getUpTime()
          • FingerObject.setAdminLevel()
          • FingerObject.setBusyMessage()
          • FingerObject.setColor()
          • FingerObject.setCreated()
          • FingerObject.setEmail()
          • FingerObject.setGameno()
          • FingerObject.setIdleTime()
          • FingerObject.setLastSeen()
          • FingerObject.setName()
          • FingerObject.setNote()
          • FingerObject.setOpponent()
          • FingerObject.setRating()
          • FingerObject.setSanctions()
          • FingerObject.setSilence()
          • FingerObject.setStatus()
          • FingerObject.setTimeseal()
          • FingerObject.setTitles()
          • FingerObject.setTotalTimeOnline()
          • FingerObject.setUpTime()
      • pychess.ic.managers.HelperManager module
        • HelperManager
          • HelperManager.on_game_add()
          • HelperManager.on_game_list()
          • HelperManager.on_game_remove()
          • HelperManager.on_player_available()
          • HelperManager.on_player_connect()
          • HelperManager.on_player_connectI()
          • HelperManager.on_player_disconnect()
          • HelperManager.on_player_disconnectI()
          • HelperManager.on_player_unavailable()
          • HelperManager.on_player_who()
          • HelperManager.on_player_whoI()
          • HelperManager.parseTitles()
      • pychess.ic.managers.ListAndVarManager module
        • ListAndVarManager
          • ListAndVarManager.addToList()
          • ListAndVarManager.autoFlagNotify()
          • ListAndVarManager.getList()
          • ListAndVarManager.onUpdateEmptyListitems()
          • ListAndVarManager.onUpdateList()
          • ListAndVarManager.onUpdateListitems()
          • ListAndVarManager.onUpdateLists()
          • ListAndVarManager.removeFromList()
      • pychess.ic.managers.NewsManager module
        • NewsManager
          • NewsManager.onNewsItem()
      • pychess.ic.managers.OfferManager module
        • OfferManager
          • OfferManager.accept()
          • OfferManager.acceptIndex()
          • OfferManager.challenge()
          • OfferManager.decline()
          • OfferManager.declineIndex()
          • OfferManager.noOffersToAccept()
          • OfferManager.notEnoughMovesToUndo()
          • OfferManager.offer()
          • OfferManager.onOfferAdd()
          • OfferManager.onOfferDeclined()
          • OfferManager.onOfferRemove()
          • OfferManager.playIndex()
          • OfferManager.withdraw()
      • pychess.ic.managers.SeekManager module
        • SeekManager
          • SeekManager.assess()
          • SeekManager.on_assess()
          • SeekManager.on_our_seeks_removed()
          • SeekManager.on_seek_add()
          • SeekManager.on_seek_clear()
          • SeekManager.on_seek_remove()
          • SeekManager.on_seek_updated()
          • SeekManager.refresh_seeks()
          • SeekManager.seek()
      • pychess.ic.managers.ICCAdjournManager module
        • ICCAdjournManager
          • ICCAdjournManager.on_icc_gamelist_begin()
          • ICCAdjournManager.on_icc_gamelist_item()
          • ICCAdjournManager.on_icc_rating_type_key()
          • ICCAdjournManager.queryJournal()
          • ICCAdjournManager.queryMoves()
      • pychess.ic.managers.ICCAutoLogOutManager module
        • ICCAutoLogOutManager
      • pychess.ic.managers.ICCBoardManager module
        • ICCBoardManager
          • ICCBoardManager.on_icc_back()
          • ICCBoardManager.on_icc_game_message()
          • ICCBoardManager.on_icc_isolated_board()
          • ICCBoardManager.on_icc_knows_fischer_random()
          • ICCBoardManager.on_icc_move_lag()
          • ICCBoardManager.on_icc_my_game_ended()
          • ICCBoardManager.on_icc_my_game_result()
          • ICCBoardManager.on_icc_my_game_started()
          • ICCBoardManager.on_icc_position_begin()
          • ICCBoardManager.on_icc_send_moves()
          • ICCBoardManager.on_icc_set_board()
          • ICCBoardManager.on_icc_spgn()
          • ICCBoardManager.on_icc_started_observing()
          • ICCBoardManager.on_icc_stop_observing()
          • ICCBoardManager.queued_send_moves
      • pychess.ic.managers.ICCChatManager module
        • ICCChatManager
          • ICCChatManager.on_icc_channel_tell()
          • ICCChatManager.on_icc_channels_shared()
          • ICCChatManager.on_icc_kibitz()
          • ICCChatManager.on_icc_people_in_my_channel()
          • ICCChatManager.on_icc_personal_tell()
          • ICCChatManager.on_icc_players_in_my_game()
          • ICCChatManager.on_icc_shout()
      • pychess.ic.managers.ICCErrorManager module
        • ICCErrorManager
          • ICCErrorManager.on_icc_illegal_move()
      • pychess.ic.managers.ICCFingerManager module
        • ICCFingerManager
          • ICCFingerManager.finger()
          • ICCFingerManager.on_icc_who_am_i()
          • ICCFingerManager.on_icc_yfinger()
      • pychess.ic.managers.ICCHelperManager module
        • ICCHelperManager
          • ICCHelperManager.on_icc_games()
          • ICCHelperManager.on_icc_player_arrived_simple()
          • ICCHelperManager.on_icc_player_left()
          • ICCHelperManager.on_icc_tourney()
          • ICCHelperManager.on_icc_wild_key()
      • pychess.ic.managers.ICCListAndVarManager module
        • ICCListAndVarManager
          • ICCListAndVarManager.autoFlagNotify()
      • pychess.ic.managers.ICCNewsManager module
        • ICCNewsManager
      • pychess.ic.managers.ICCOfferManager module
        • ICCOfferManager
          • ICCOfferManager.accept()
          • ICCOfferManager.decline()
          • ICCOfferManager.on_icc_match()
          • ICCOfferManager.on_icc_match_removed()
          • ICCOfferManager.on_icc_offers_in_my_game()
      • pychess.ic.managers.ICCSeekManager module
        • ICCSeekManager
          • ICCSeekManager.on_icc_seek_add()
          • ICCSeekManager.on_icc_seek_removed()
      • Module contents
  • Submodules
  • pychess.ic.FICSConnection module
    • LogOnException
    • Connection
      • Connection.cancel()
      • Connection.close()
      • Connection.expect()
      • Connection.expect_cn_line()
      • Connection.expect_dg_line()
      • Connection.expect_fromABplus()
      • Connection.expect_fromplus()
      • Connection.expect_fromto()
      • Connection.expect_line()
      • Connection.expect_n_lines()
      • Connection.getUsername()
      • Connection.isConnected()
      • Connection.isConnecting()
      • Connection.isRegistred()
      • Connection.unexpect()
      • Connection.ics_name
    • FICSConnection
      • FICSConnection.cancel()
      • FICSConnection.close()
      • FICSConnection.start()
    • FICSHelperConnection
    • FICSMainConnection
      • FICSMainConnection.close()
      • FICSMainConnection.start_helper_manager()
  • pychess.ic.FICSObjects module
    • AlreadyExistException
    • FICSAdjournedGame
      • FICSAdjournedGame.display_time
      • FICSAdjournedGame.opponent
    • FICSBoard
    • FICSChallenge
    • FICSChallenges
      • FICSChallenges.clear()
      • FICSChallenges.onChallengeIssued()
      • FICSChallenges.onChallengeRemoved()
      • FICSChallenges.onPlayingGame()
      • FICSChallenges.start()
    • FICSGame
      • FICSGame.get_private()
      • FICSGame.set_private()
      • FICSGame.update()
      • FICSGame.display_text
      • FICSGame.private
      • FICSGame.supported
    • FICSGames
      • FICSGames.game_ended()
      • FICSGames.get()
      • FICSGames.get_game_by_gameno()
      • FICSGames.items()
      • FICSGames.keys()
      • FICSGames.onAdjournmentsList()
      • FICSGames.onCurGameEnded()
      • FICSGames.onHistoryList()
      • FICSGames.onJournalList()
      • FICSGames.start()
      • FICSGames.values()
    • FICSHistoryGame
      • FICSHistoryGame.display_time
    • FICSJournalGame
      • FICSJournalGame.display_time
    • FICSMatch
      • FICSMatch.display_rated
      • FICSMatch.display_timecontrol
      • FICSMatch.sortable_time
    • FICSPlayer
      • FICSPlayer.display_titles()
      • FICSPlayer.getIcon()
      • FICSPlayer.getIconByRating()
      • FICSPlayer.getMarkup()
      • FICSPlayer.getRatingByGameType()
      • FICSPlayer.getRatingForCurrentGame()
      • FICSPlayer.getRatingMean()
      • FICSPlayer.getStrength()
      • FICSPlayer.get_game()
      • FICSPlayer.get_online()
      • FICSPlayer.get_status()
      • FICSPlayer.get_titles()
      • FICSPlayer.isAdmin()
      • FICSPlayer.isAvailableForGame()
      • FICSPlayer.isComputer()
      • FICSPlayer.isGuest()
      • FICSPlayer.isObservable()
      • FICSPlayer.isTitled()
      • FICSPlayer.long_name()
      • FICSPlayer.restore_previous_status()
      • FICSPlayer.set_game()
      • FICSPlayer.set_online()
      • FICSPlayer.set_status()
      • FICSPlayer.set_titles()
      • FICSPlayer.atomic
      • FICSPlayer.blitz
      • FICSPlayer.bughouse
      • FICSPlayer.crazyhouse
      • FICSPlayer.display_online
      • FICSPlayer.display_status
      • FICSPlayer.game
      • FICSPlayer.lightning
      • FICSPlayer.losers
      • FICSPlayer.online
      • FICSPlayer.standard
      • FICSPlayer.status
      • FICSPlayer.suicide
      • FICSPlayer.titles
      • FICSPlayer.wild
    • FICSPlayers
      • FICSPlayers.get()
      • FICSPlayers.get_online_playernames()
      • FICSPlayers.items()
      • FICSPlayers.keys()
      • FICSPlayers.online_changed()
      • FICSPlayers.player_disconnected()
      • FICSPlayers.start()
      • FICSPlayers.values()
    • FICSSeek
    • FICSSeeks
      • FICSSeeks.clear()
      • FICSSeeks.onAddSeek()
      • FICSSeeks.onClearSeeks()
      • FICSSeeks.onCurGameEnded()
      • FICSSeeks.onRemoveSeek()
      • FICSSeeks.start()
    • FICSSoughtMatch
      • FICSSoughtMatch.player_rating
    • get_challenge_tooltip_text()
    • get_player_tooltip_text()
    • get_rating_range_display_text()
    • get_seek_tooltip_text()
    • get_soughtmatch_tooltip_text()
    • make_sensitive_if_available()
    • make_sensitive_if_playing()
    • player_id()
  • pychess.ic.ICGameModel module
    • ICGameModel
      • ICGameModel.acceptReceived()
      • ICGameModel.backToMainLine()
      • ICGameModel.checkStatus()
      • ICGameModel.end()
      • ICGameModel.ficsplayer()
      • ICGameModel.goFirst()
      • ICGameModel.goLast()
      • ICGameModel.goNext()
      • ICGameModel.goPrev()
      • ICGameModel.hasGuestPlayers()
      • ICGameModel.offerReceived()
      • ICGameModel.onActionError()
      • ICGameModel.onBoardSetup()
      • ICGameModel.onDisconnected()
      • ICGameModel.onExGameReset()
      • ICGameModel.onGameEnded()
      • ICGameModel.onGamePaused()
      • ICGameModel.onGameUndoing()
      • ICGameModel.onKibitzMessage()
      • ICGameModel.onMadeExamined()
      • ICGameModel.onMadeUnExamined()
      • ICGameModel.onObserversReceived()
      • ICGameModel.onTimesUpdate()
      • ICGameModel.onWhisperMessage()
      • ICGameModel.setPlayers()
      • ICGameModel.terminate()
      • ICGameModel.update_board()
      • ICGameModel.display_text
      • ICGameModel.noTD
      • ICGameModel.remote_ficsplayer
      • ICGameModel.remote_player
  • pychess.ic.ICLogon module
    • AutoLogoutException
    • ICLogon
      • ICLogon.get_user_names()
      • ICLogon.hide()
      • ICLogon.host_get_value()
      • ICLogon.host_set_value()
      • ICLogon.onAutologout()
      • ICLogon.onCancel()
      • ICLogon.onConnectClicked()
      • ICLogon.onConnected()
      • ICLogon.onConnectionError()
      • ICLogon.onCreateNew()
      • ICLogon.onHelperConnectionError()
      • ICLogon.onLogout()
      • ICLogon.on_ics_combo_changed()
      • ICLogon.on_logOnAsGuest_toggled()
      • ICLogon.on_timeseal_toggled()
      • ICLogon.password_set_value()
      • ICLogon.present()
      • ICLogon.show()
      • ICLogon.showConnecting()
      • ICLogon.showError()
      • ICLogon.showMessage()
      • ICLogon.showNormal()
      • ICLogon.user_name_get_value()
      • ICLogon.user_name_set_value()
    • run()
    • stop()
  • pychess.ic.TimeSeal module
    • CanceledException
    • ICSStreamReader
      • ICSStreamReader.read_until()
    • ICSStreamReaderProtocol
      • ICSStreamReaderProtocol.cook_some()
      • ICSStreamReaderProtocol.data_received()
      • ICSStreamReaderProtocol.decode()
      • ICSStreamReaderProtocol.encode()
    • ICSTelnet
      • ICSTelnet.cancel()
      • ICSTelnet.close()
      • ICSTelnet.get_init_string()
      • ICSTelnet.read_until()
      • ICSTelnet.readline()
      • ICSTelnet.readuntil()
      • ICSTelnet.start()
      • ICSTelnet.write()
      • ICSTelnet.sensitive
  • pychess.ic.VerboseTelnet module
    • ConsoleHandler
      • ConsoleHandler.handle()
    • FromABPlusPrediction
      • FromABPlusPrediction.handle()
    • FromPlusPrediction
      • FromPlusPrediction.handle()
    • FromToPrediction
      • FromToPrediction.handle()
    • LinePrediction
      • LinePrediction.handle()
    • MultipleLinesPrediction
    • NLinesPrediction
      • NLinesPrediction.handle()
    • Prediction
    • PredictionsTelnet
      • PredictionsTelnet.cancel()
      • PredictionsTelnet.close()
      • PredictionsTelnet.parse()
      • PredictionsTelnet.run_command()
      • PredictionsTelnet.test_prediction()
    • TelnetLine
      • TelnetLine.code
      • TelnetLine.code_type
      • TelnetLine.line
    • TelnetLines
      • TelnetLines.appendleft()
      • TelnetLines.extendleft()
      • TelnetLines.popleft()
  • Module contents
    • GameType
      • GameType.variant
    • NormalGameType
    • VariantGameType
      • VariantGameType.display_text
      • VariantGameType.seek_text
    • WildGameType
      • WildGameType.instances()
    • get_infobarmessage_content()
    • get_infobarmessage_content2()
    • parseRating()
    • parse_title_hex()
    • time_control_to_gametype()
    • type_to_display_text()
• pychess.perspectives package
  • Subpackages
    • pychess.perspectives.database package
      • Submodules
      • pychess.perspectives.database.FilterPanel module
        • formatted()
      • pychess.perspectives.database.OpeningTreePanel module
      • pychess.perspectives.database.PreviewPanel module
        • PreviewPanel
          • PreviewPanel.on_add_clicked()
          • PreviewPanel.on_filter_clicked()
          • PreviewPanel.on_first_clicked()
          • PreviewPanel.on_last_clicked()
          • PreviewPanel.on_next_clicked()
          • PreviewPanel.on_prev_clicked()
          • PreviewPanel.on_selection_changed()
          • PreviewPanel.update_gamelist()
      • pychess.perspectives.database.gamelist module
      • Module contents
        • Database
          • Database.close()
          • Database.create_book()
          • Database.create_database()
          • Database.create_toolbuttons()
          • Database.do_import()
          • Database.feed_book()
          • Database.get_tabcontent()
          • Database.importing()
          • Database.init_layout()
          • Database.on_chessfile_opened0()
          • Database.on_import_clicked()
          • Database.on_import_endgame_nl()
          • Database.on_import_twic()
          • Database.on_save_as_clicked()
          • Database.on_switch_page()
          • Database.open_chessfile()
          • Database.process_records()
          • Database.save_records()
          • Database.set_sensitives()
          • Database.filter_panel
          • Database.gamelist
          • Database.opening_tree_panel
          • Database.preview_panel
        • get_latest_twic()
    • pychess.perspectives.fics package
      • Submodules
      • pychess.perspectives.fics.ArchiveListPanel module
        • Sidepanel
          • Sidepanel.compareFunction()
          • Sidepanel.getSelectedPlayer()
          • Sidepanel.load()
          • Sidepanel.onAbortButtonClicked()
          • Sidepanel.onAdjournedGameAdded()
          • Sidepanel.onAdjournedGameRemoved()
          • Sidepanel.onDrawButtonClicked()
          • Sidepanel.onExamineButtonClicked()
          • Sidepanel.onGamePreview()
          • Sidepanel.onHistoryGameAdded()
          • Sidepanel.onHistoryGameRemoved()
          • Sidepanel.onJournalGameAdded()
          • Sidepanel.onJournalGameRemoved()
          • Sidepanel.onMygamesButtonClicked()
          • Sidepanel.onPlayGameCreated()
          • Sidepanel.onPreviewButtonClicked()
          • Sidepanel.onResignButtonClicked()
          • Sidepanel.onResumeButtonClicked()
          • Sidepanel.onSelectionChanged()
          • Sidepanel.on_game_start()
          • Sidepanel.online_changed()
          • Sidepanel.status_changed()
      • pychess.perspectives.fics.ChatPanel module
        • Sidepanel
          • Sidepanel.focus_in()
          • Sidepanel.load()
          • Sidepanel.onConversationAdded()
          • Sidepanel.onConversationRemoved()
          • Sidepanel.onConversationSelected()
          • Sidepanel.openChatWithPlayer()
        • get_playername()
      • pychess.perspectives.fics.ConsolePanel module
        • Sidepanel
          • Sidepanel.filter_unprintable()
          • Sidepanel.load()
          • Sidepanel.onConsoleMessage()
          • Sidepanel.scroll_to_bottom()
      • pychess.perspectives.fics.FicsHome module
        • UserInfoSection
          • UserInfoSection.onFinger()
      • pychess.perspectives.fics.GameListPanel module
        • Sidepanel
          • Sidepanel.compareFunction()
          • Sidepanel.game_filter_func()
          • Sidepanel.getSelectedPlayer()
          • Sidepanel.load()
          • Sidepanel.onGameAdd()
          • Sidepanel.onGameObserved()
          • Sidepanel.onGameRemove()
          • Sidepanel.onGameUnobserved()
          • Sidepanel.onSelectionChanged()
          • Sidepanel.on_filter_button_toggled()
          • Sidepanel.on_query_tooltip()
          • Sidepanel.on_sort_column_change()
          • Sidepanel.private_changed()
      • pychess.perspectives.fics.NewsPanel module
        • Sidepanel
          • Sidepanel.load()
          • Sidepanel.onNewsItem()
      • pychess.perspectives.fics.ParrentListSection module
        • ParrentListSection
          • ParrentListSection.addColumns()
          • ParrentListSection.button_press_event()
          • ParrentListSection.createLocalMenu()
          • ParrentListSection.lowLeftSearchPosFunc()
          • ParrentListSection.on_accept()
          • ParrentListSection.on_archived()
          • ParrentListSection.on_assess()
          • ParrentListSection.on_challenge()
          • ParrentListSection.on_chat()
          • ParrentListSection.on_finger()
          • ParrentListSection.on_follow()
          • ParrentListSection.on_observe()
          • ParrentListSection.pixCompareFunction()
          • ParrentListSection.timeCompareFunction()
        • cmp()
      • pychess.perspectives.fics.PlayerListPanel module
        • Sidepanel
          • Sidepanel.elo_changed()
          • Sidepanel.getSelectedPlayer()
          • Sidepanel.load()
          • Sidepanel.onPlayerAdded()
          • Sidepanel.onPlayerRemoved()
          • Sidepanel.onSelectionChanged()
          • Sidepanel.on_filter_button_toggled()
          • Sidepanel.player_filter_func()
          • Sidepanel.private_changed()
          • Sidepanel.status_changed()
          • Sidepanel.titles_changed()
      • pychess.perspectives.fics.SeekChallenge module
        • SeekChallengeSection
          • SeekChallengeSection.onChallengeButtonClicked()
          • SeekChallengeSection.onChallengeDialogResponse()
          • SeekChallengeSection.onChallengeRadioConfigButtonClicked()
          • SeekChallengeSection.onColorRadioChanged()
          • SeekChallengeSection.onEditSeekDialogResponse()
          • SeekChallengeSection.onFinger()
          • SeekChallengeSection.onRatingCenterSliderChanged()
          • SeekChallengeSection.onSeekAllButtonClicked()
          • SeekChallengeSection.onSeekButtonClicked()
          • SeekChallengeSection.onSeekRadioConfigButtonClicked()
          • SeekChallengeSection.onStrengthCheckToggled()
          • SeekChallengeSection.onTimeSpinChanged()
          • SeekChallengeSection.onToleranceButtonClicked()
          • SeekChallengeSection.onToleranceSliderChanged()
          • SeekChallengeSection.onUntimedCheckToggled()
          • SeekChallengeSection.onVariantComboChanged()
          • SeekChallengeSection.onVariantRadioChanged()
          • SeekChallengeSection.seekEditorWidgetDefaults
          • SeekChallengeSection.seekEditorWidgetGettersSetters
          • SeekChallengeSection.seekEditorWidgets
      • pychess.perspectives.fics.SeekGraphPanel module
        • Sidepanel
          • Sidepanel.load()
          • Sidepanel.onAddSought()
          • Sidepanel.onCurGameEnded()
          • Sidepanel.onPlayingGame()
          • Sidepanel.onRemoveSought()
          • Sidepanel.onSpotClicked()
        • XLOCATION()
        • YLOCATION()
      • pychess.perspectives.fics.SeekListPanel module
        • Sidepanel
          • Sidepanel.compareFunction()
          • Sidepanel.getSelectedPlayer()
          • Sidepanel.load()
          • Sidepanel.onAddSeek()
          • Sidepanel.onAssessReceived()
          • Sidepanel.onChallengeAdd()
          • Sidepanel.onChallengeRemove()
          • Sidepanel.onClearSeeksClicked()
          • Sidepanel.onCurGameEnded()
          • Sidepanel.onDeclineClicked()
          • Sidepanel.onPlayingGame()
          • Sidepanel.onRemoveSeek()
          • Sidepanel.onSelectionChanged()
          • Sidepanel.on_filter_button_toggled()
          • Sidepanel.our_seeks_removed()
          • Sidepanel.row_activated()
          • Sidepanel.seek_filter_func()
          • Sidepanel.selectFunction()
          • Sidepanel.textcolor_normal()
          • Sidepanel.textcolor_selected()
      • Module contents
        • FICS
          • FICS.close()
          • FICS.create_toolbuttons()
          • FICS.init_layout()
          • FICS.matchDeclined()
          • FICS.nonoWhileExamine()
          • FICS.onArrivalNotification()
          • FICS.onDepartedNotification()
          • FICS.onFinger()
          • FICS.onGameModelStarted()
          • FICS.onObserveGameCreated()
          • FICS.onPlayGameCreated()
          • FICS.on_connection_error()
          • FICS.on_seek_updated()
          • FICS.open_lounge()
          • FICS.our_seeks_removed()
          • FICS.player_on_censor()
          • FICS.player_on_noplay()
          • FICS.present()
          • FICS.req_not_fit_formula()
          • FICS.show()
          • FICS.tooManySeeks()
          • FICS.user_from_notify_list_is_present()
    • pychess.perspectives.games package
      • Submodules
      • pychess.perspectives.games.annotationPanel module
      • pychess.perspectives.games.bookPanel module
      • pychess.perspectives.games.chatPanel module
        • Sidepanel
          • Sidepanel.load()
          • Sidepanel.onGameStarted()
          • Sidepanel.onICMessageReieved()
          • Sidepanel.onMessageRecieved()
          • Sidepanel.onMessageSent()
          • Sidepanel.on_game_terminated()
      • pychess.perspectives.games.commentPanel module
        • Sidepanel
          • Sidepanel.addComment()
          • Sidepanel.cursorChanged()
          • Sidepanel.game_changed()
          • Sidepanel.game_started()
          • Sidepanel.load()
          • Sidepanel.moves_undone()
          • Sidepanel.on_game_terminated()
          • Sidepanel.shownChanged()
      • pychess.perspectives.games.engineOutputPanel module
        • Sidepanel
          • Sidepanel.game_changed()
          • Sidepanel.game_started()
          • Sidepanel.load()
          • Sidepanel.on_game_terminated()
          • Sidepanel.players_changed()
          • Sidepanel.updateVisibleOutputs()
      • pychess.perspectives.games.historyPanel module
        • Sidepanel
          • Sidepanel.add_move()
          • Sidepanel.game_changed()
          • Sidepanel.game_started()
          • Sidepanel.get_background_rgba()
          • Sidepanel.load()
          • Sidepanel.moves_undone()
          • Sidepanel.on_game_terminated()
          • Sidepanel.on_row_activated()
          • Sidepanel.on_style_updated()
          • Sidepanel.ply_to_row_col()
          • Sidepanel.shownChanged()
      • pychess.perspectives.games.scorePanel module
        • Sidepanel
          • Sidepanel.analysis_changed()
          • Sidepanel.fetch_chess_conf()
          • Sidepanel.game_changed()
          • Sidepanel.game_started()
          • Sidepanel.load()
          • Sidepanel.moves_undone()
          • Sidepanel.on_game_terminated()
          • Sidepanel.plot_selected()
          • Sidepanel.shownChanged()
      • Module contents
        • Games
          • Games.adjust_divider()
          • Games.attachGameWidget()
          • Games.closeAllGames()
          • Games.closeGame()
          • Games.cur_gmwidg()
          • Games.customGetTabLabelText()
          • Games.delGameWidget()
          • Games.generalStart()
          • Games.getheadbook()
          • Games.init_layout()
          • Games.saveGame()
          • Games.saveGameAs()
          • Games.saveGamePGN()
          • Games.saveGameSimple()
          • Games.show_tabs()
          • Games.tabsCallback()
          • Games.zoomToBoard()
        • get_open_dialog()
        • get_save_dialog()
    • pychess.perspectives.learn package
      • Submodules
      • pychess.perspectives.learn.EndgamesPanel module
      • pychess.perspectives.learn.LecturesPanel module
      • pychess.perspectives.learn.LessonsPanel module
      • pychess.perspectives.learn.PuzzlesPanel module
      • Module contents
    • pychess.perspectives.welcome package
      • Module contents
  • Module contents
    • Perspective
      • Perspective.activate_panel()
      • Perspective.close()
      • Perspective.create_toolbuttons()
      • Perspective.load_from_xml()
      • Perspective.on_clicked()
      • Perspective.on_toggled()
      • Perspective.sensitive
    • PerspectiveManager
      • PerspectiveManager.activate_perspective()
      • PerspectiveManager.add_perspective()
      • PerspectiveManager.disable_perspective()
      • PerspectiveManager.get_perspective()
      • PerspectiveManager.on_persp_toggled()
      • PerspectiveManager.set_perspective_menuitems()
      • PerspectiveManager.set_perspective_toolbuttons()
      • PerspectiveManager.set_perspective_widget()
      • PerspectiveManager.set_widgets()
    • panel_name()
• pychess.widgets package
  • Subpackages
    • pychess.widgets.pydock package
      • Submodules
      • pychess.widgets.pydock.ArrowButton module
      • pychess.widgets.pydock.HighlightArea module
        • ceil()
      • pychess.widgets.pydock.OverlayWindow module
      • pychess.widgets.pydock.PyDockComposite module
        • PyDockComposite
          • PyDockComposite.changeComponent()
          • PyDockComposite.dock()
          • PyDockComposite.getComponents()
          • PyDockComposite.getPosition()
          • PyDockComposite.initChildren()
          • PyDockComposite.removeComponent()
      • pychess.widgets.pydock.PyDockLeaf module
        • PyDockLeaf
          • PyDockLeaf.dock()
          • PyDockLeaf.getCurrentPanel()
          • PyDockLeaf.getPanels()
          • PyDockLeaf.hideArrows()
          • PyDockLeaf.isDockable()
          • PyDockLeaf.setCurrentPanel()
          • PyDockLeaf.setDockable()
          • PyDockLeaf.showArrows()
          • PyDockLeaf.undock()
          • PyDockLeaf.zoomDown()
          • PyDockLeaf.zoomUp()
      • pychess.widgets.pydock.PyDockTop module
        • PyDockTop
          • PyDockTop.addComponent()
          • PyDockTop.changeComponent()
          • PyDockTop.clear()
          • PyDockTop.dock()
          • PyDockTop.getComponents()
          • PyDockTop.getPosition()
          • PyDockTop.hideArrows()
          • PyDockTop.loadFromXML()
          • PyDockTop.old2new()
          • PyDockTop.removeComponent()
          • PyDockTop.saveToXML()
          • PyDockTop.showArrows()
      • pychess.widgets.pydock.StarArrowButton module
        • ceil()
      • Module contents
        • TabReceiver
          • TabReceiver.getInstances()
          • TabReceiver.hideArrows()
          • TabReceiver.showArrows()
  • Submodules
  • pychess.widgets.Background module
    • expose()
    • giveBackground()
    • hexcol()
    • isDarkTheme()
    • newTheme()
  • pychess.widgets.BoardControl module
    • ActiveState
      • ActiveState.isSelectable()
      • ActiveState.motion()
      • ActiveState.release()
    • BoardState
      • BoardState.getBoard()
      • BoardState.isSelectable()
      • BoardState.leave()
      • BoardState.motion()
      • BoardState.point2Cord()
      • BoardState.press()
      • BoardState.release()
      • BoardState.transPoint()
      • BoardState.validate()
    • LockedActiveState
      • LockedActiveState.isSelectable()
      • LockedActiveState.motion()
      • LockedActiveState.release()
    • LockedBoardState
      • LockedBoardState.isAPotentiallyLegalNextMove()
    • LockedNormalState
      • LockedNormalState.isSelectable()
      • LockedNormalState.press()
    • LockedSelectedState
      • LockedSelectedState.isSelectable()
      • LockedSelectedState.motion()
      • LockedSelectedState.press()
    • NormalState
      • NormalState.isSelectable()
      • NormalState.press()
    • SelectedState
      • SelectedState.isSelectable()
      • SelectedState.press()
  • pychess.widgets.BoardView module
    • contains()
    • intersects()
    • join()
    • matrixAround()
    • rect()
    • union()
  • pychess.widgets.BorderBox module
    • BorderBox
      • BorderBox.isBottom()
      • BorderBox.isLeft()
      • BorderBox.isRight()
      • BorderBox.isTop()
      • BorderBox.setBottom()
      • BorderBox.setLeft()
      • BorderBox.setRight()
      • BorderBox.setTop()
      • BorderBox.bottom
      • BorderBox.left
      • BorderBox.right
      • BorderBox.top
  • pychess.widgets.ChainVBox module
    • ChainLine
      • ChainLine.draw()
      • ChainLine.on_draw()
      • ChainLine.on_size_allocate()
  • pychess.widgets.ChannelsPanel module
  • pychess.widgets.ChatView module
  • pychess.widgets.ChessClock module
  • pychess.widgets.ExternalsDialog module
    • ExternalsDialog
      • ExternalsDialog.on_close_clicked()
      • ExternalsDialog.show()
  • pychess.widgets.ImageMenu module
    • switchWithImage()
  • pychess.widgets.InfoBar module
    • InfoBarMessageButton
      • InfoBarMessageButton.get_sensitive()
      • InfoBarMessageButton.get_tooltip_text()
      • InfoBarMessageButton.set_sensitive()
      • InfoBarMessageButton.set_tooltip_text()
      • InfoBarMessageButton.sensitive
      • InfoBarMessageButton.tooltip_text
    • InfoBarNotebook
      • InfoBarNotebook.clear_messages()
      • InfoBarNotebook.customGetTabLabelText()
      • InfoBarNotebook.push_message()
    • get_message_content()
  • pychess.widgets.InfoPanel module
  • pychess.widgets.LearnInfoBar module
  • pychess.widgets.MenuItemsDict module
    • GtkMenuItem
      • GtkMenuItem.update()
      • GtkMenuItem.label
      • GtkMenuItem.sensitive
      • GtkMenuItem.tooltip
    • GtkMenuToggleButton
      • GtkMenuToggleButton.update()
      • GtkMenuToggleButton.active
    • MenuItemsDict
      • MenuItemsDict.ANAL_MENU_ITEMS
      • MenuItemsDict.VIEW_MENU_ITEMS
  • pychess.widgets.PieceWidget module
  • pychess.widgets.PromotionDialog module
    • PromotionDialog
      • PromotionDialog.runAndHide()
      • PromotionDialog.setColor()
  • pychess.widgets.RecentChooser module
  • pychess.widgets.SpotGraph module
    • ceil()
  • pychess.widgets.TaskerManager module
  • pychess.widgets.ViewsPanel module
  • pychess.widgets.WebKitBrowser module
    • WebKitBrowser
      • WebKitBrowser.change_title()
      • WebKitBrowser.check_buttons()
      • WebKitBrowser.go()
      • WebKitBrowser.go_back()
      • WebKitBrowser.go_forward()
      • WebKitBrowser.refresh()
      • WebKitBrowser.search()
    • open_link()
  • pychess.widgets.analyzegameDialog module
    • AnalyzeGameDialog
      • AnalyzeGameDialog.run()
  • pychess.widgets.discovererDialog module
    • DiscovererDialog
      • DiscovererDialog.all_whatcher()
      • DiscovererDialog.close()
      • DiscovererDialog.discovered_whatcher()
      • DiscovererDialog.start()
  • pychess.widgets.enginesDialog module
  • pychess.widgets.gameinfoDialog module
    • initialize()
    • on_pick_date()
    • refresh_elo_rating_change()
    • run()
  • pychess.widgets.gamenanny module
    • GameNanny
      • GameNanny.engineDead()
      • GameNanny.game_ended()
      • GameNanny.nurseGame()
      • GameNanny.offer_callback()
      • GameNanny.on_disconnected()
      • GameNanny.on_game_started()
      • GameNanny.on_game_terminated()
      • GameNanny.on_gmwidg_closed()
      • GameNanny.on_gmwidg_title_changed()
  • pychess.widgets.gamewidget module
    • GameWidget
      • GameWidget.analyzer_added()
      • GameWidget.analyzer_removed()
      • GameWidget.bringToFront()
      • GameWidget.clearMessages()
      • GameWidget.find_in_database()
      • GameWidget.game_changed()
      • GameWidget.game_ended()
      • GameWidget.game_paused()
      • GameWidget.game_resumed()
      • GameWidget.game_saved()
      • GameWidget.game_started()
      • GameWidget.game_unended()
      • GameWidget.getPageNumber()
      • GameWidget.hide_arrow()
      • GameWidget.infobar_hidden()
      • GameWidget.infront()
      • GameWidget.initBoardAndClock()
      • GameWidget.initButtons()
      • GameWidget.initTabcontents()
      • GameWidget.isInFront()
      • GameWidget.light_on_off()
      • GameWidget.message_received()
      • GameWidget.moves_undone()
      • GameWidget.name_changed()
      • GameWidget.on_game_close_clicked()
      • GameWidget.on_shapes_changed()
      • GameWidget.on_show_fics_gameno()
      • GameWidget.opp_not_out_of_time()
      • GameWidget.player_display_text()
      • GameWidget.player_lagged()
      • GameWidget.players_changed()
      • GameWidget.replaceMessages()
      • GameWidget.save_shapes_to_pgn()
      • GameWidget.setLocked()
      • GameWidget.showMessage()
      • GameWidget.show_arrow()
      • GameWidget.shownChanged()
      • GameWidget.zero_reached()
      • GameWidget.display_text
    • getWidgets()
    • hideDesignGW()
    • isDesignGWShown()
    • setWidgets()
    • showDesignGW()
  • pychess.widgets.newGameDialog module
    • EnterNotationExtension
      • EnterNotationExtension.run()
    • NewGameMode
      • NewGameMode.run()
    • SetupPositionExtension
      • SetupPositionExtension.castl_toggled()
      • SetupPositionExtension.ep_combo_changed()
      • SetupPositionExtension.fen_changed()
      • SetupPositionExtension.fifty_spin_changed()
      • SetupPositionExtension.game_changed()
      • SetupPositionExtension.get_fen()
      • SetupPositionExtension.ini_widgets()
      • SetupPositionExtension.moveno_spin_changed()
      • SetupPositionExtension.rotate_button_pressed()
      • SetupPositionExtension.run()
      • SetupPositionExtension.side_button_toggled()
      • SetupPositionExtension.board_control
    • createPlayerUIGlobals()
    • createRematch()
    • loadFileAndRun()
    • loadPgnAndRun()
  • pychess.widgets.playerinfoDialog module
  • pychess.widgets.preferencesDialog module
    • GeneralTab
    • HintTab
    • PanelTab
      • PanelTab.hideit()
      • PanelTab.panel_about()
      • PanelTab.panel_toggled()
      • PanelTab.selection_changed()
      • PanelTab.showit()
    • SaveTab
    • SoundTab
      • SoundTab.getPlayer()
      • SoundTab.playAction()
      • SoundTab.SOUND_DIRS
      • SoundTab.actionToKeyNo
      • SoundTab.i
      • SoundTab.soundcombo
      • SoundTab.sounduri
    • ThemeTab
      • ThemeTab.discoverThemes()
    • anal_combo_get_value()
    • anal_combo_set_value()
    • initialize()
    • run()
  • pychess.widgets.tipOfTheDay module
    • TipOfTheDay
      • TipOfTheDay.set_currentIndex()
      • TipOfTheDay.show()
      • TipOfTheDay.shuffleTips()
      • TipOfTheDay.xorshift()
  • Module contents
    • createAlignment()
    • createImage()
    • dock_panel_tab()
    • insert_formatted()
    • mainwindow()
    • new_notebook()

Submodules

pychess.Main module

Module contents