Motor de ajedrez de Python. Error de llamada de profundidad excedida en la función Alphabeta.

Recientemente he estado trabajando en un proyecto cuyo objetivo es hacer un motor de ajedrez que pueda evaluar una posición determinada y jugar los mejores movimientos. Utilicé esta publicación como base para este proyecto, pero me di cuenta de que no era lo que estaba buscando.
Código fuente: github

Mi código:

def do_move(depth):

try:
move = chess.polyglot.MemoryMappedReader(“C:/Users/Bruno/Desktop/pws/books/human.bin”).weighted_choice(board).move
move = chess.polyglot.MemoryMappedReader(“C:/Users/Bruno/Desktop/pws/books/computer.bin”).weighted_choice(board).move
move = chess.polyglot.MemoryMappedReader(“C:/Users/Bruno/Desktop/pws/books/pecg_book.bin”).weighted_choice(board).move
return move
except:
bestMove = chess.Move.null()
bestValue = -99999
alpha = -100000
beta = 100000
for move in board.legal_moves:
board.push(move)
boardValue = -alphabeta(-beta, -alpha, (depth -1))
if boardValue > bestValue:
bestValue = boardValue
bestMove = move
if (boardValue > alpha):
alpha = boardValue
board.pop()
return bestMove

def alphabeta(depthleft, alpha, beta):
bestscore = -9999
if (depthleft == 0):
return quiesce(alpha, beta)
for move in board.legal_moves:
board.push(move)
score = -alphabeta(-beta, -alpha, depthleft – 1)
board.pop()
if (score >= beta):
return score
if (score > bestscore):
bestscore = score
if (score > alpha):
alpha = score
return bestscore

def quiesce(alpha, beta):
stand_pat = evaluation()
if (stand_pat >= beta):
return beta
if (alpha < stand_pat):
alpha = stand_pat
for move in board.legal_moves:
if board.is_capture(move):
board.push(move)
score = -quiesce(-beta, -alpha)
board.pop()
if (score >= beta):
return beta
if (score > alpha):
alpha = score
return alpha

Actualmente, el código puede realizar alrededor de 20 movimientos antes de fallar debido a llamadas excesivas a la función do_move().

¿Cómo puedo solucionarlo y hacer que juegue una partida completa?