def ReplaySGF()

in pachi_py/extra_unused.pyx [0:0]

• 92 lines of code
• 30 McCabe index (conditional complexity)

def ReplaySGF(const char* filename):
    # Adapted from sgf2gtp.py in pachi

    with open(filename, 'r') as f:
        sgfdata = f.read()
    col = SGFParser(sgfdata).parse()
    assert len(col) == 1

    gametree = col[0]

    class UnknownNode(Exception):
        pass

    def get_atr(node, atr):
        try:
            return node.data[atr].data[0]
        except KeyError:
            return None

    def get_setup(node, atr):
        try:
            return node.data[atr].data[:]
        except KeyError:
            return None

    def col2num(column, board_size):
        a, o, z = map(ord, ['a', column, 'z'])
        if a <= o <= z:
            return a + board_size - o
        raise Exception( "Wrong column character: '%s'"%(column,) )

    def is_pass_move(coord, board_size):
        # the pass move is represented either by [] ( = empty coord )
        # OR by [tt] (for boards <= 19 only)
        return len(coord) == 0 or ( board_size <= 19 and coord == 'tt' )

    def record_step(PyPachiBoard b, object coord):
        cdef move m
        if is_pass_move(coord, bsize):
            m = move_from_gtp(b._b.pachiboard(), player_next, 'pass')
        else:
            x, y = coord
            # The reason for this incredibly weird thing is that
            # the GTP protocol excludes `i` in the coordinates
            # (do you see any purpose in this??)
            if x >= 'i':
                x = chr(ord(x)+1)
            y = str(col2num(y, bsize))
            m = move_from_gtp(b._b.pachiboard(), player_next, x+y)

        cdef PyPachiBoard next_b = play_move(b, m)
        return Transition(
            m.color,
            b,
            m.coord,
            next_b
        )

    # cursor for tree traversal
    c = gametree.cursor()
    # first node is the header
    header = c.node

    handicap = get_atr(header, 'HA')
    bsize = int(get_atr(header, 'SZ') or 19)
    # assert bsize == 19

    komi = get_atr(header, 'KM')
    player_next, player_other = 'B', 'W'
    setup_black = get_setup(header, 'AB')
    setup_white = get_setup(header, 'AW')
    ruleset = get_atr(header, 'RU')

    cdef PyPachiBoard b = CreateBoard(bsize)

    # if komi:
    #     b._pachi_board.komi = float(komi)
    if handicap and handicap != '0':
        #board_handicap(b._pachi_board, int(handicap), NULL)
        # The dataset seems to have explicit AB/AW for handicap stones
        # so don't use Pachi's add-handicap method here
        player_next, player_other = player_other, player_next
    if setup_black:
        for item in setup_black:
            x, y = item
            if x >= 'i':
                x = chr(ord(x)+1)
            y = str(col2num(y, bsize))
            b = play_gtp(b, 'B', x+y)
    if setup_white:
        for item in setup_white:
            x, y = item
            if x >= 'i':
                x = chr(ord(x)+1)
            y = str(col2num(y, bsize))
            b = play_gtp(b, 'W', x+y)
    if ruleset:
        if ruleset.lower() == 'nz':
            # board_set_rules only takes new_zealand
            ruleset = 'new_zealand'
        if not board_set_rules(b._b.pachiboard(), ruleset):
            print 'Unrecognized ruleset %s for %s, defaulting to Pachi default' % (ruleset, filename)

    # walk the game tree forward
    game_transitions = []
    while True:
        # sgf2gtp.pl ignores n = 0
        if c.atEnd:
            break
        c.next()

        coord = get_atr(c.node, player_next)
        if coord != None:
            game_transitions.append(record_step(b, coord))
            b = game_transitions[-1].next_state
        else:
            # MAYBE white started?
            # or one of the players plays two time in a row
            player_next, player_other = player_other, player_next
            coord = get_atr(c.node, player_next)
            if coord != None:
                game_transitions.append(record_step(b, coord))
                b = game_transitions[-1].next_state
            elif len(c.node) != 0:
                # TODO handle weird sgf files better
                raise UnknownNode

        player_next, player_other = player_other, player_next
    return game_transitions