chess-mnemonic-protocol 0.1.0__tar.gz

chess_mnemonic_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: chess-mnemonic-protocol
+Version: 0.1.0
+Summary: Chess Mnemonic Protocol tools
+Project-URL: Repository, https://github.com/julesora/cmp
+Project-URL: Specification, https://github.com/julesora/cmp/blob/main/spec/cmp-0001.md
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+CMP
+===
+
+CMP is a small text format for legal chess move sequences.
+CMP 1 stores moves in lowercase UCI.
+
+Quick Start
+-----------
+
+* Check a value: cmp check cmp1 e2e4 e7e5
+* Normalize a value: cmp normalize CMP1 E2E4 E7E5
+* Convert to SAN: cmp convert --to san cmp1 e2e4 e7e5
+* Convert to PGN: cmp convert --to pgn cmp1 e2e4 e7e5
+* List legal moves: cmp legal e2e4 e7e5
+
+Install for development:
+
+    python -m pip install -e .
+
+Format
+------
+
+A CMP 1 value starts with cmp1 followed by legal UCI moves:
+
+    cmp1 e2e4 e7e5 g1f3 b8c6
+
+The main rules are:
+
+* moves are lowercase UCI
+* moves must be legal
+* legal move lists are sorted
+* a finished game resets to the start position
+
+See spec/cmp-0001.md for the full format.
+
+Python API
+----------
+
+    import cmp
+
+    line = 'cmp1 e2e4 e7e5 g1f3'
+
+    cmp.check(line)
+    cmp.normalize(line)
+    cmp.parse_mnemonic(line)
+    cmp.legal_moves()
+    cmp.convert_mnemonic(line, 'san')
+    cmp.convert_mnemonic(line, 'pgn')
+
+CMP text always uses UCI. SAN and PGN are output formats.
+
+Documentation
+-------------
+
+* Format: spec/cmp-0001.md
+* Test vectors: vectors.json
+* Changes: CHANGELOG.md
+* Contributing: CONTRIBUTING.md
+* Security: SECURITY.md
+
+Source
+------
+
+* cmp.py: parser, API and command line
+* chess_engine.py: chess rules
+* tests/test_cmp.py: tests
+
+Development
+-----------
+
+Run the tests with:
+
+    python -m unittest discover -s tests -v

chess_mnemonic_protocol-0.1.0/README

@@ -0,0 +1,73 @@
+CMP
+===
+
+CMP is a small text format for legal chess move sequences.
+CMP 1 stores moves in lowercase UCI.
+
+Quick Start
+-----------
+
+* Check a value: cmp check cmp1 e2e4 e7e5
+* Normalize a value: cmp normalize CMP1 E2E4 E7E5
+* Convert to SAN: cmp convert --to san cmp1 e2e4 e7e5
+* Convert to PGN: cmp convert --to pgn cmp1 e2e4 e7e5
+* List legal moves: cmp legal e2e4 e7e5
+
+Install for development:
+
+    python -m pip install -e .
+
+Format
+------
+
+A CMP 1 value starts with cmp1 followed by legal UCI moves:
+
+    cmp1 e2e4 e7e5 g1f3 b8c6
+
+The main rules are:
+
+* moves are lowercase UCI
+* moves must be legal
+* legal move lists are sorted
+* a finished game resets to the start position
+
+See spec/cmp-0001.md for the full format.
+
+Python API
+----------
+
+    import cmp
+
+    line = 'cmp1 e2e4 e7e5 g1f3'
+
+    cmp.check(line)
+    cmp.normalize(line)
+    cmp.parse_mnemonic(line)
+    cmp.legal_moves()
+    cmp.convert_mnemonic(line, 'san')
+    cmp.convert_mnemonic(line, 'pgn')
+
+CMP text always uses UCI. SAN and PGN are output formats.
+
+Documentation
+-------------
+
+* Format: spec/cmp-0001.md
+* Test vectors: vectors.json
+* Changes: CHANGELOG.md
+* Contributing: CONTRIBUTING.md
+* Security: SECURITY.md
+
+Source
+------
+
+* cmp.py: parser, API and command line
+* chess_engine.py: chess rules
+* tests/test_cmp.py: tests
+
+Development
+-----------
+
+Run the tests with:
+
+    python -m unittest discover -s tests -v

chess_mnemonic_protocol-0.1.0/chess_engine.py

@@ -0,0 +1,423 @@
+FILES = 'abcdefgh'
+PROMOTIONS = 'qrbn'
+KNIGHT_STEPS = ((1,2),(2,1),(2,-1),(1,-2),(-1,-2),(-2,-1),(-2,1),(-1,2))
+BISHOP_DIRS = ((1,1),(1,-1),(-1,1),(-1,-1))
+ROOK_DIRS = ((1,0),(-1,0),(0,1),(0,-1))
+
+
+def _sq(file, rank):
+    return rank * 8 + file
+
+
+def _file(square):
+    return square & 7
+
+
+def _rank(square):
+    return square >> 3
+
+
+def _inside(file, rank):
+    return 0 <= file < 8 and 0 <= rank < 8
+
+
+def _other(color):
+    return 'b' if color == 'w' else 'w'
+
+
+def _color(piece):
+    if not piece:
+        return None
+    return 'w' if piece.isupper() else 'b'
+
+
+def _type(piece):
+    if not piece:
+        return None
+    return piece.lower()
+
+
+def _name(square):
+    return '%s%d' % (FILES[_file(square)], _rank(square) + 1)
+
+
+def initial_state():
+    board = [None] * 64
+    back = 'rnbqkbnr'
+
+    for file in range(8):
+        board[_sq(file, 0)] = back[file].upper()
+        board[_sq(file, 1)] = 'P'
+        board[_sq(file, 6)] = 'p'
+        board[_sq(file, 7)] = back[file]
+
+    return {
+        'board': board,
+        'turn': 'w',
+        'castling': set('KQkq'),
+        'ep': None,
+    }
+
+
+def _copy(state):
+    return {
+        'board': state['board'].copy(),
+        'turn': state['turn'],
+        'castling': state['castling'].copy(),
+        'ep': state['ep'],
+    }
+
+
+def _attacked(state, target, color):
+    board = state['board']
+    target_file = _file(target)
+    target_rank = _rank(target)
+    pawn_rank = target_rank + (-1 if color == 'w' else 1)
+
+    for df in (-1, 1):
+        file = target_file + df
+        if _inside(file, pawn_rank):
+            piece = board[_sq(file, pawn_rank)]
+            if piece and _color(piece) == color and _type(piece) == 'p':
+                return True
+
+    for df, dr in KNIGHT_STEPS:
+        file = target_file + df
+        rank = target_rank + dr
+        if _inside(file, rank):
+            piece = board[_sq(file, rank)]
+            if piece and _color(piece) == color and _type(piece) == 'n':
+                return True
+
+    for dirs, pieces in ((BISHOP_DIRS, 'bq'), (ROOK_DIRS, 'rq')):
+        for df, dr in dirs:
+            file = target_file + df
+            rank = target_rank + dr
+            while _inside(file, rank):
+                piece = board[_sq(file, rank)]
+                if piece:
+                    if _color(piece) == color and _type(piece) in pieces:
+                        return True
+                    break
+                file += df
+                rank += dr
+
+    for df in (-1, 0, 1):
+        for dr in (-1, 0, 1):
+            if not (df or dr):
+                continue
+            file = target_file + df
+            rank = target_rank + dr
+            if _inside(file, rank):
+                piece = board[_sq(file, rank)]
+                if piece and _color(piece) == color and _type(piece) == 'k':
+                    return True
+
+    return False
+
+
+def _in_check(state, color):
+    king = 'K' if color == 'w' else 'k'
+    try:
+        square = state['board'].index(king)
+    except ValueError:
+        return True
+    return _attacked(state, square, _other(color))
+
+
+def _castling_moves(state, start, add):
+    board = state['board']
+    turn = state['turn']
+    rank = 0 if turn == 'w' else 7
+
+    if start != _sq(4, rank) or _in_check(state, turn):
+        return
+
+    enemy = _other(turn)
+    rook = 'R' if turn == 'w' else 'r'
+    king_side = 'K' if turn == 'w' else 'k'
+    queen_side = 'Q' if turn == 'w' else 'q'
+
+    if king_side in state['castling'] and board[_sq(7, rank)] == rook:
+        if not board[_sq(5, rank)] and not board[_sq(6, rank)]:
+            safe = not _attacked(state, _sq(5, rank), enemy)
+            safe = safe and not _attacked(state, _sq(6, rank), enemy)
+            if safe:
+                add(start, _sq(6, rank))
+
+    if queen_side in state['castling'] and board[_sq(0, rank)] == rook:
+        clear = not board[_sq(1, rank)]
+        clear = clear and not board[_sq(2, rank)]
+        clear = clear and not board[_sq(3, rank)]
+        if clear:
+            safe = not _attacked(state, _sq(3, rank), enemy)
+            safe = safe and not _attacked(state, _sq(2, rank), enemy)
+            if safe:
+                add(start, _sq(2, rank))
+
+
+def _pseudo_moves(state):
+    moves = []
+    board = state['board']
+    turn = state['turn']
+
+    def add(start, end, promotion=''):
+        moves.append((start, end, promotion))
+
+    for start, piece in enumerate(board):
+        if not piece or _color(piece) != turn:
+            continue
+
+        kind = _type(piece)
+        file = _file(start)
+        rank = _rank(start)
+
+        if kind == 'p':
+            step = 1 if turn == 'w' else -1
+            home = 1 if turn == 'w' else 6
+            promo = 7 if turn == 'w' else 0
+            one = rank + step
+
+            if _inside(file, one) and not board[_sq(file, one)]:
+                end = _sq(file, one)
+                if one == promo:
+                    for promotion in PROMOTIONS:
+                        add(start, end, promotion)
+                else:
+                    add(start, end)
+
+                two = rank + (2 * step)
+                if rank == home and not board[_sq(file, two)]:
+                    add(start, _sq(file, two))
+
+            for df in (-1, 1):
+                capture_file = file + df
+                capture_rank = rank + step
+                if not _inside(capture_file, capture_rank):
+                    continue
+
+                end = _sq(capture_file, capture_rank)
+                target = board[end]
+                capture = target and _color(target) != turn
+                if capture or state['ep'] == end:
+                    if capture_rank == promo:
+                        for promotion in PROMOTIONS:
+                            add(start, end, promotion)
+                    else:
+                        add(start, end)
+            continue
+
+        if kind == 'n':
+            for df, dr in KNIGHT_STEPS:
+                next_file = file + df
+                next_rank = rank + dr
+                if not _inside(next_file, next_rank):
+                    continue
+                end = _sq(next_file, next_rank)
+                if not board[end] or _color(board[end]) != turn:
+                    add(start, end)
+            continue
+
+        if kind in 'brq':
+            if kind == 'b':
+                dirs = BISHOP_DIRS
+            elif kind == 'r':
+                dirs = ROOK_DIRS
+            else:
+                dirs = BISHOP_DIRS + ROOK_DIRS
+
+            for df, dr in dirs:
+                next_file = file + df
+                next_rank = rank + dr
+                while _inside(next_file, next_rank):
+                    end = _sq(next_file, next_rank)
+                    if not board[end]:
+                        add(start, end)
+                    else:
+                        if _color(board[end]) != turn:
+                            add(start, end)
+                        break
+                    next_file += df
+                    next_rank += dr
+            continue
+
+        if kind == 'k':
+            for df in (-1, 0, 1):
+                for dr in (-1, 0, 1):
+                    if not (df or dr):
+                        continue
+                    next_file = file + df
+                    next_rank = rank + dr
+                    if _inside(next_file, next_rank):
+                        end = _sq(next_file, next_rank)
+                        if not board[end] or _color(board[end]) != turn:
+                            add(start, end)
+            _castling_moves(state, start, add)
+
+    return moves
+
+
+def _apply(state, move):
+    start, end, promotion = move
+    new_state = _copy(state)
+    board = new_state['board']
+    piece = board[start]
+    color = _color(piece)
+    kind = _type(piece)
+    captured = board[end]
+    start_name = _name(start)
+    end_name = _name(end)
+
+    board[start] = None
+
+    if kind == 'p' and state['ep'] == end and not captured:
+        if _file(start) != _file(end):
+            offset = -8 if color == 'w' else 8
+            board[end + offset] = None
+
+    if promotion:
+        piece = promotion.upper() if color == 'w' else promotion
+
+    board[end] = piece
+
+    if kind == 'k' and abs(_file(end) - _file(start)) == 2:
+        rank = _rank(start)
+        king_side = _file(end) == 6
+        rook_from = _sq(7 if king_side else 0, rank)
+        rook_to = _sq(5 if king_side else 3, rank)
+        board[rook_to] = board[rook_from]
+        board[rook_from] = None
+
+    if kind == 'k':
+        new_state['castling'].discard('K' if color == 'w' else 'k')
+        new_state['castling'].discard('Q' if color == 'w' else 'q')
+
+    rights = (('h1','K'),('a1','Q'),('h8','k'),('a8','q'))
+    for square, right in rights:
+        if start_name == square or end_name == square:
+            new_state['castling'].discard(right)
+
+    new_state['ep'] = None
+    if kind == 'p' and abs(_rank(end) - _rank(start)) == 2:
+        new_state['ep'] = (start + end) >> 1
+
+    new_state['turn'] = _other(state['turn'])
+    return new_state
+
+
+def _uci(move):
+    start, end, promotion = move
+    return _name(start) + _name(end) + promotion
+
+
+def _legal_objects(state):
+    color = state['turn']
+    moves = []
+
+    for move in _pseudo_moves(state):
+        if not _in_check(_apply(state, move), color):
+            moves.append(move)
+
+    return moves
+
+
+def _find_move(state, uci):
+    uci = str(uci).strip().lower()
+    for move in _legal_objects(state):
+        if _uci(move) == uci:
+            return move
+    raise ValueError('illegal move: %s' % uci)
+
+
+def legal_moves(state):
+    moves = [_uci(move) for move in _legal_objects(state)]
+    moves.sort()
+    return moves
+
+
+def _is_capture(state, move):
+    start, end, unused = move
+    piece = state['board'][start]
+
+    if state['board'][end]:
+        return True
+
+    return (
+        _type(piece) == 'p'
+        and state['ep'] == end
+        and _file(start) != _file(end)
+    )
+
+
+def _san_prefix(state, move, legal):
+    start, end, unused = move
+    board = state['board']
+    kind = _type(board[start])
+
+    if kind == 'p':
+        return FILES[_file(start)] if _is_capture(state, move) else ''
+
+    prefix = kind.upper()
+    others = []
+    for candidate in legal:
+        if candidate == move or candidate[1] != end:
+            continue
+        if _type(board[candidate[0]]) == kind:
+            others.append(candidate)
+
+    if not others:
+        return prefix
+
+    same_file = any(_file(other[0]) == _file(start) for other in others)
+    same_rank = any(_rank(other[0]) == _rank(start) for other in others)
+
+    if not same_file:
+        return prefix + FILES[_file(start)]
+    if not same_rank:
+        return prefix + str(_rank(start) + 1)
+    return prefix + _name(start)
+
+
+def san(state, uci):
+    legal = _legal_objects(state)
+    uci = str(uci).strip().lower()
+    move = None
+
+    for candidate in legal:
+        if _uci(candidate) == uci:
+            move = candidate
+            break
+
+    if move is None:
+        raise ValueError('illegal move: %s' % uci)
+
+    start, end, promotion = move
+    kind = _type(state['board'][start])
+
+    if kind == 'k' and abs(_file(end) - _file(start)) == 2:
+        text = 'O-O' if _file(end) == 6 else 'O-O-O'
+    else:
+        text = _san_prefix(state, move, legal)
+        if _is_capture(state, move):
+            text += 'x'
+        text += _name(end)
+        if promotion:
+            text += '=' + promotion.upper()
+
+    next_state = _apply(state, move)
+    if _in_check(next_state, next_state['turn']):
+        text += '#' if not _legal_objects(next_state) else '+'
+
+    return text
+
+
+def play(state, uci):
+    return _apply(state, _find_move(state, uci))
+
+
+def result(state):
+    if _legal_objects(state):
+        return None
+    if not _in_check(state, state['turn']):
+        return '1/2-1/2'
+    return '0-1' if state['turn'] == 'w' else '1-0'

chess_mnemonic_protocol-0.1.0/chess_mnemonic_protocol.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: chess-mnemonic-protocol
+Version: 0.1.0
+Summary: Chess Mnemonic Protocol tools
+Project-URL: Repository, https://github.com/julesora/cmp
+Project-URL: Specification, https://github.com/julesora/cmp/blob/main/spec/cmp-0001.md
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+CMP
+===
+
+CMP is a small text format for legal chess move sequences.
+CMP 1 stores moves in lowercase UCI.
+
+Quick Start
+-----------
+
+* Check a value: cmp check cmp1 e2e4 e7e5
+* Normalize a value: cmp normalize CMP1 E2E4 E7E5
+* Convert to SAN: cmp convert --to san cmp1 e2e4 e7e5
+* Convert to PGN: cmp convert --to pgn cmp1 e2e4 e7e5
+* List legal moves: cmp legal e2e4 e7e5
+
+Install for development:
+
+    python -m pip install -e .
+
+Format
+------
+
+A CMP 1 value starts with cmp1 followed by legal UCI moves:
+
+    cmp1 e2e4 e7e5 g1f3 b8c6
+
+The main rules are:
+
+* moves are lowercase UCI
+* moves must be legal
+* legal move lists are sorted
+* a finished game resets to the start position
+
+See spec/cmp-0001.md for the full format.
+
+Python API
+----------
+
+    import cmp
+
+    line = 'cmp1 e2e4 e7e5 g1f3'
+
+    cmp.check(line)
+    cmp.normalize(line)
+    cmp.parse_mnemonic(line)
+    cmp.legal_moves()
+    cmp.convert_mnemonic(line, 'san')
+    cmp.convert_mnemonic(line, 'pgn')
+
+CMP text always uses UCI. SAN and PGN are output formats.
+
+Documentation
+-------------
+
+* Format: spec/cmp-0001.md
+* Test vectors: vectors.json
+* Changes: CHANGELOG.md
+* Contributing: CONTRIBUTING.md
+* Security: SECURITY.md
+
+Source
+------
+
+* cmp.py: parser, API and command line
+* chess_engine.py: chess rules
+* tests/test_cmp.py: tests
+
+Development
+-----------
+
+Run the tests with:
+
+    python -m unittest discover -s tests -v

chess_mnemonic_protocol-0.1.0/chess_mnemonic_protocol.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README
+chess_engine.py
+cmp.py
+pyproject.toml
+chess_mnemonic_protocol.egg-info/PKG-INFO
+chess_mnemonic_protocol.egg-info/SOURCES.txt
+chess_mnemonic_protocol.egg-info/dependency_links.txt
+chess_mnemonic_protocol.egg-info/entry_points.txt
+chess_mnemonic_protocol.egg-info/top_level.txt
+tests/test_cmp.py

chess_mnemonic_protocol-0.1.0/chess_mnemonic_protocol.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chess_mnemonic_protocol-0.1.0/chess_mnemonic_protocol.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cmp = cmp:main

chess_mnemonic_protocol-0.1.0/chess_mnemonic_protocol.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+chess_engine
+cmp

chess_mnemonic_protocol-0.1.0/cmp.py

@@ -0,0 +1,243 @@
+import argparse
+import re
+import sys
+
+from chess_engine import initial_state
+from chess_engine import legal_moves as chess_moves
+from chess_engine import play
+from chess_engine import result as chess_result
+from chess_engine import san as chess_san
+
+VERSION = 'cmp1'
+PROTOCOL_VERSION = VERSION
+__version__ = '0.1.0'
+
+UCI_RE = re.compile(r'^[a-h][1-8][a-h][1-8][qrbn]?$')
+
+
+class CMPError(ValueError):
+    pass
+
+
+class InvalidMnemonic(CMPError):
+    pass
+
+
+def _split(mnemonic):
+    words = str(mnemonic).strip().lower().split()
+    if not words or words[0] != VERSION:
+        raise InvalidMnemonic('mnemonic must start with %s' % VERSION)
+    if len(words) == 1:
+        raise InvalidMnemonic('mnemonic has no moves')
+    return words[1:]
+
+
+def _check_move(move, number):
+    if not UCI_RE.match(move):
+        raise InvalidMnemonic(
+            'move %d is not canonical UCI: %s' % (number, move)
+        )
+
+
+def _next(state, move, number):
+    _check_move(move, number)
+
+    if not chess_moves(state):
+        state = initial_state()
+
+    try:
+        return play(state, move)
+    except ValueError:
+        raise InvalidMnemonic('illegal move %d (%s)' % (number, move))
+
+
+def _play_moves(moves):
+    state = initial_state()
+    for number, move in enumerate(moves, 1):
+        state = _next(state, move, number)
+    return state
+
+
+def parse_mnemonic(mnemonic):
+    moves = _split(mnemonic)
+    _play_moves(moves)
+    return tuple(moves)
+
+
+def normalize(mnemonic):
+    return VERSION + ' ' + ' '.join(parse_mnemonic(mnemonic))
+
+
+def check(mnemonic):
+    try:
+        parse_mnemonic(mnemonic)
+        return True
+    except (TypeError, ValueError):
+        return False
+
+
+def _moves(value):
+    if isinstance(value, str):
+        words = value.strip().lower().split()
+        if words and words[0] == VERSION:
+            return list(parse_mnemonic(value))
+        return words
+    return [str(move).strip().lower() for move in value]
+
+
+def legal_moves(moves=()):
+    moves = _moves(moves)
+    state = initial_state()
+
+    for number, move in enumerate(moves, 1):
+        state = _next(state, move, number)
+
+    return chess_moves(state)
+
+
+def _san_games(moves):
+    games = []
+    game = []
+    state = initial_state()
+
+    for move in moves:
+        if not chess_moves(state):
+            games.append((game, chess_result(state)))
+            game = []
+            state = initial_state()
+
+        game.append(chess_san(state, move))
+        state = play(state, move)
+
+    games.append((game, chess_result(state)))
+    return games
+
+
+def _san_text(moves):
+    words = []
+
+    for number, move in enumerate(moves):
+        if number % 2 == 0:
+            words.append('%d. %s' % ((number // 2) + 1, move))
+        else:
+            words.append(move)
+
+    return ' '.join(words)
+
+
+def _pgn(game, result, number):
+    result = result or '*'
+    headers = [
+        '[Event "CMP-1"]',
+        '[Site "?"]',
+        '[Date "????.??.??"]',
+        '[Round "%d"]' % number,
+        '[White "?"]',
+        '[Black "?"]',
+        '[Result "%s"]' % result,
+    ]
+
+    moves = _san_text(game)
+    if moves:
+        moves += ' '
+    moves += result
+
+    return '\n'.join(headers) + '\n\n' + moves
+
+
+def convert_mnemonic(mnemonic, format='pgn'):
+    moves = parse_mnemonic(mnemonic)
+    format = str(format).strip().lower()
+
+    if format == 'uci':
+        return ' '.join(moves)
+
+    games = _san_games(moves)
+
+    if format == 'san':
+        return '\n'.join(_san_text(game) for game, result in games)
+
+    if format == 'pgn':
+        blocks = []
+        for number, item in enumerate(games, 1):
+            game, result = item
+            blocks.append(_pgn(game, result, number))
+        return '\n\n'.join(blocks)
+
+    raise ValueError('format must be uci, san, or pgn')
+
+
+def _parser():
+    parser = argparse.ArgumentParser(prog='cmp')
+    parser.add_argument(
+        '--version',
+        action='version',
+        version='cmp %s (protocol %s)' % (__version__, VERSION),
+    )
+
+    commands = parser.add_subparsers(dest='command', required=True)
+
+    command = commands.add_parser('check', help='validate a mnemonic')
+    command.add_argument('mnemonic', nargs='+')
+
+    command = commands.add_parser('normalize', help='normalize a mnemonic')
+    command.add_argument('mnemonic', nargs='+')
+
+    command = commands.add_parser('convert', help='convert chess notation')
+    command.add_argument('--to', choices=('uci', 'san', 'pgn'), default='pgn')
+    command.add_argument('mnemonic', nargs='+')
+
+    command = commands.add_parser('legal', help='list legal moves')
+    command.add_argument('moves', nargs='*')
+
+    return parser
+
+
+def _text(words):
+    return ' '.join(words)
+
+
+def main(argv=None):
+    args = _parser().parse_args(argv)
+
+    if args.command == 'check':
+        try:
+            parse_mnemonic(_text(args.mnemonic))
+        except InvalidMnemonic as error:
+            print('invalid: %s' % error, file=sys.stderr)
+            return 1
+        print('valid')
+        return 0
+
+    if args.command == 'normalize':
+        print(normalize(_text(args.mnemonic)))
+        return 0
+
+    if args.command == 'convert':
+        print(convert_mnemonic(_text(args.mnemonic), args.to))
+        return 0
+
+    if args.command == 'legal':
+        print(' '.join(legal_moves(args.moves)))
+        return 0
+
+    return 2
+
+
+__all__ = [
+    'CMPError',
+    'InvalidMnemonic',
+    'PROTOCOL_VERSION',
+    'VERSION',
+    '__version__',
+    'check',
+    'convert_mnemonic',
+    'legal_moves',
+    'main',
+    'normalize',
+    'parse_mnemonic',
+]
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

chess_mnemonic_protocol-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chess-mnemonic-protocol"
+version = "0.1.0"
+description = "Chess Mnemonic Protocol tools"
+readme = {file = "README", content-type = "text/markdown"}
+requires-python = ">=3.8"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+]
+
+[project.urls]
+Repository = "https://github.com/julesora/cmp"
+Specification = "https://github.com/julesora/cmp/blob/main/spec/cmp-0001.md"
+
+[project.scripts]
+cmp = "cmp:main"
+
+[tool.setuptools]
+py-modules = ["cmp", "chess_engine"]

chess_mnemonic_protocol-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chess_mnemonic_protocol-0.1.0/tests/test_cmp.py

@@ -0,0 +1,172 @@
+import contextlib
+import io
+import json
+import os
+import unittest
+
+import cmp
+from chess_engine import initial_state
+from chess_engine import legal_moves as engine_legal_moves
+from chess_engine import play
+
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class CMPTests(unittest.TestCase):
+    def test_chess_starts_with_20_moves(self):
+        moves = cmp.legal_moves()
+        self.assertEqual(len(moves), 20)
+        self.assertEqual(moves, sorted(moves))
+
+    def test_normalize(self):
+        self.assertEqual(
+            cmp.normalize('  CMP1   E2E4   E7E5  '),
+            'cmp1 e2e4 e7e5',
+        )
+
+    def test_check_returns_boolean(self):
+        self.assertTrue(cmp.check('cmp1 e2e4 e7e5'))
+        self.assertFalse(cmp.check('cmp1 e2e5'))
+        self.assertFalse(cmp.check('e2e4'))
+
+    def test_parse_returns_canonical_moves(self):
+        self.assertEqual(
+            cmp.parse_mnemonic('CMP1 E2E4 E7E5'),
+            ('e2e4', 'e7e5'),
+        )
+
+    def test_invalid_error_contains_move_index(self):
+        with self.assertRaisesRegex(cmp.InvalidMnemonic, r'move 2'):
+            cmp.parse_mnemonic('cmp1 e2e4 d2d4')
+
+    def test_convert_uci(self):
+        line = 'cmp1 e2e4 e7e5 g1f3 b8c6 f1b5'
+        self.assertEqual(
+            cmp.convert_mnemonic(line, 'uci'),
+            'e2e4 e7e5 g1f3 b8c6 f1b5',
+        )
+
+    def test_convert_san(self):
+        line = 'cmp1 e2e4 e7e5 g1f3 b8c6 f1b5'
+        self.assertEqual(
+            cmp.convert_mnemonic(line, 'san'),
+            '1. e4 e5 2. Nf3 Nc6 3. Bb5',
+        )
+
+    def test_convert_pgn(self):
+        line = 'cmp1 e2e4 e7e5 g1f3 b8c6 f1b5'
+        pgn = cmp.convert_mnemonic(line, 'pgn')
+        self.assertIn('[Event "CMP-1"]', pgn)
+        self.assertIn('[Result "*"]', pgn)
+        self.assertTrue(pgn.endswith('1. e4 e5 2. Nf3 Nc6 3. Bb5 *'))
+
+    def test_checkmate_pgn_result(self):
+        line = 'cmp1 e2e4 e7e5 d1h5 b8c6 f1c4 g8f6 h5f7'
+        pgn = cmp.convert_mnemonic(line, 'pgn')
+        self.assertIn('[Result "1-0"]', pgn)
+        self.assertTrue(pgn.endswith('Qxf7# 1-0'))
+
+    def test_san_castling_en_passant_and_promotion(self):
+        line = (
+            'cmp1 e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 '
+            'b5a4 g8f6 e1g1'
+        )
+        self.assertTrue(cmp.convert_mnemonic(line, 'san').endswith('O-O'))
+
+        line = 'cmp1 e2e4 a7a6 e4e5 d7d5 e5d6'
+        self.assertTrue(cmp.convert_mnemonic(line, 'san').endswith('exd6'))
+
+        line = (
+            'cmp1 a2a4 h7h5 a4a5 h5h4 a5a6 h4h3 '
+            'a6b7 h3g2 b7a8q'
+        )
+        self.assertTrue(cmp.convert_mnemonic(line, 'san').endswith('bxa8=Q'))
+
+    def test_restart_after_terminal_position(self):
+        line = 'cmp1 e2e4 e7e5 d1h5 b8c6 f1c4 g8f6 h5f7 e2e4'
+        self.assertTrue(cmp.check(line))
+        self.assertEqual(
+            cmp.convert_mnemonic(line, 'san'),
+            '1. e4 e5 2. Qh5 Nc6 3. Bc4 Nf6 4. Qxf7#\n1. e4',
+        )
+        pgn = cmp.convert_mnemonic(line, 'pgn')
+        self.assertEqual(pgn.count('[Event "CMP-1"]'), 2)
+
+    def test_vectors(self):
+        path = os.path.join(ROOT, 'vectors.json')
+        with open(path, 'r', encoding='utf-8') as handle:
+            vectors = json.load(handle)
+
+        self.assertEqual(vectors['protocol'], cmp.VERSION)
+
+        for vector in vectors['valid']:
+            with self.subTest(vector=vector['name']):
+                self.assertTrue(cmp.check(vector['input']))
+                self.assertEqual(
+                    cmp.normalize(vector['input']),
+                    vector['canonical'],
+                )
+                self.assertEqual(
+                    cmp.convert_mnemonic(vector['input'], 'uci'),
+                    vector['uci'],
+                )
+                self.assertEqual(
+                    cmp.convert_mnemonic(vector['input'], 'san'),
+                    vector['san'],
+                )
+                if 'pgn_result' in vector:
+                    result = '[Result "%s"]' % vector['pgn_result']
+                    self.assertIn(
+                        result,
+                        cmp.convert_mnemonic(vector['input'], 'pgn'),
+                    )
+
+        for vector in vectors['invalid']:
+            with self.subTest(vector=vector['name']):
+                self.assertFalse(cmp.check(vector['input']))
+                with self.assertRaises(cmp.InvalidMnemonic):
+                    cmp.parse_mnemonic(vector['input'])
+
+    def test_cli_check_and_convert(self):
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            code = cmp.main(['check', 'cmp1', 'e2e4', 'e7e5'])
+        self.assertEqual(code, 0)
+        self.assertEqual(stdout.getvalue().strip(), 'valid')
+
+        stdout = io.StringIO()
+        with contextlib.redirect_stdout(stdout):
+            code = cmp.main([
+                'convert', '--to', 'san', 'cmp1', 'e2e4', 'e7e5'
+            ])
+        self.assertEqual(code, 0)
+        self.assertEqual(stdout.getvalue().strip(), '1. e4 e5')
+
+    def test_cli_invalid_returns_nonzero(self):
+        stderr = io.StringIO()
+        with contextlib.redirect_stderr(stderr):
+            code = cmp.main(['check', 'cmp1', 'e2e5'])
+        self.assertEqual(code, 1)
+        self.assertIn('invalid:', stderr.getvalue())
+
+
+class ChessEngineTests(unittest.TestCase):
+    def perft(self, state, depth):
+        if depth == 0:
+            return 1
+
+        total = 0
+        for move in engine_legal_moves(state):
+            total += self.perft(play(state, move), depth - 1)
+        return total
+
+    def test_start_position_perft(self):
+        state = initial_state()
+        self.assertEqual(self.perft(state, 1), 20)
+        self.assertEqual(self.perft(state, 2), 400)
+        self.assertEqual(self.perft(state, 3), 8902)
+
+
+if __name__ == '__main__':
+    unittest.main()