Main.py

from stockfish import Stockfish
from flask import *
import time
import pyuac
from flask import jsonify

# Variables
STOCKFISH_PATH = r"stockfish-windows-x86-64\stockfish\stockfish-windows-x86-64.exe"
app = Flask(__name__)
dict = []
stockfish = Stockfish(path=STOCKFISH_PATH)


# Error handlers
@app.errorhandler(400)
def bad_request_error(error):
    """
    Error handler for 400 Bad Request.

    Args:
        error: The error object representing the bad request.

    Returns:
        A JSON response with an error message and status code 400.
    """
    return jsonify({"error": "Bad request"}), 400


@app.errorhandler(500)
def internal_server_error(error):
    """
    Handle internal server errors.

    Args:
        error: The error object.

    Returns:
        A JSON response with an error message and a status code of 500.
    """
    return jsonify({"error": "Internal server error"}), 500


# Methods
@app.route("/", methods=["GET"])
def home_page():
    """
    Returns a welcome message for the home page.

    This function returns a string that welcomes the user to the home page and provides a link to the documentation.

    Returns:
        str: A welcome message with a link to the documentation.
    """
    return (
        "Welcome to the Home Page!. Read the documentation for more info!\nGithub: "
        "https://github.com/vigneshsaravanakumar404/Stockfish_API"
    )


@app.route("/engine/elo/", methods=["GET"])
def new_engine_elo_page():
    """
    Handle GET request for '/engine/elo/' endpoint.
    This function receives parameters from the request and updates the Stockfish engine parameters accordingly.
    It then sets the FEN position and the ELO rating for the engine.
    Finally, it returns the best move calculated by the engine.

    Returns:
        str: The best move calculated by the Stockfish engine.

    Raises:
        Exception: If there is an error during the execution, an error message is logged and a JSON response with an error message is returned.
    """
    try:
        contempt = str(request.args.get("contempt"))
        min_split_depth = str(request.args.get("min-split-depth"))
        ponder = str(request.args.get("ponder"))
        minimum_thinking_time = str(request.args.get("minimum-thinking-time"))
        uci_chess960 = str(request.args.get("uci-chess960"))
        uci_limit_strength = str(request.args.get("uci-limit-strength"))
        fen = str(request.args.get("fen"))

        elo = int(request.args.get("uci_elo")) or 1350

        dict.append(["Contempt", contempt])
        dict.append(["Min Split Depth", min_split_depth])
        dict.append(["Ponder", ponder])
        dict.append(["Minimum Thinking Time", minimum_thinking_time])
        dict.append(["UCI_Chess960", uci_chess960])
        dict.append(["UCI_LimitStrength", uci_limit_strength])

        parameters = {}
        for item in dict:
            if item[1] != "None":
                parameters[item[0]] = item[1]

        # Set default value for fen if it is not provided
        if fen is None:
            fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

        stockfish.update_engine_parameters(parameters)
        stockfish.set_fen_position(fen)
        stockfish.set_elo_rating(int(elo))

        return stockfish.get_best_move()

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


@app.route("/engine/level/", methods=["GET"])
def engine_level_page():
    """
    API endpoint for setting the engine level and getting the best move.

    Parameters:
    - contempt (str): The contempt value for the engine.
    - min-split-depth (str): The minimum split depth value for the engine.
    - ponder (str): The ponder value for the engine.
    - minimum-thinking-time (str): The minimum thinking time value for the engine.
    - uci-chess960 (str): The UCI Chess960 value for the engine.
    - uci-limit-strength (str): The UCI LimitStrength value for the engine.
    - fen (str): The FEN position for the engine. If not provided, a default FEN position is used.
    - skill-level (int): The skill level for the engine. Default value is 1350.

    Returns:
    - str: The best move calculated by the engine.

    Raises:
    - Exception: If there is an error processing the request.

    """
    try:
        contempt = str(request.args.get("contempt"))
        min_split_depth = str(request.args.get("min-split-depth"))
        ponder = str(request.args.get("ponder"))
        minimum_thinking_time = str(request.args.get("minimum-thinking-time"))
        uci_chess960 = str(request.args.get("uci-chess960"))
        uci_limit_strength = str(request.args.get("uci-limit-strength"))
        fen = str(request.args.get("fen"))

        skillLevel = int(request.args.get("skill-level")) or 1350

        dict.append(["Contempt", contempt])
        dict.append(["Min Split Depth", min_split_depth])
        dict.append(["Ponder", ponder])
        dict.append(["Minimum Thinking Time", minimum_thinking_time])
        dict.append(["UCI_Chess960", uci_chess960])
        dict.append(["UCI_LimitStrength", uci_limit_strength])

        parameters = {}
        for item in dict:
            if item[1] != "None":
                parameters[item[0]] = item[1]

        # Set default value for fen if it is not provided
        if fen is None:
            fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

        stockfish.update_engine_parameters(parameters)
        stockfish.set_fen_position(fen)
        stockfish.set_skill_level(int(skillLevel))

        return stockfish.get_best_move()

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


@app.route("/is-fen-valid/", methods=["GET"])
def is_fen_valid_page():
    """
    Endpoint to check if a given FEN (Forsyth-Edwards Notation) string is valid.

    Parameters:
        fen (str): The FEN string to be validated.

    Returns:
        str: A string representation of the validity of the FEN string.

    Raises:
        Exception: If there is an error during the validation process.

    """
    try:
        fen = str(request.args.get("fen"))
        return str(stockfish.is_fen_valid(fen))

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


@app.route("/is-move-correct/", methods=["GET"])
def is_move_correct_page():
    """
    Checks if a given chess move is correct based on the current board position.

    Parameters:
        fen (str): The FEN (Forsyth–Edwards Notation) representation of the current board position.
        move (str): The chess move to be checked.

    Returns:
        str: A string representation of the correctness of the move. Returns 'True' if the move is correct, 'False' otherwise.

    Raises:
        Exception: If there is an error in the input parameters.

    """
    try:
        fen = str(request.args.get("fen"))
        move = str(request.args.get("move"))
        stockfish.set_fen_position(fen)
        return str(stockfish.is_move_correct(move))

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


@app.route("/get-top-moves/", methods=["GET"])
def get_top_moves_page():
    """
    Retrieves the top moves for a given FEN position.

    Args:
        fen (str): The FEN position.
        number (int): The number of top moves to retrieve.

    Returns:
        str: A string representation of the top moves.

    Raises:
        Exception: If there is an error processing the request.

    """
    print("request got here")
    try:
        fen = str(request.args.get("fen"))
        number = int(request.args.get("number"))
        stockfish.set_fen_position(fen)
        return str(stockfish.get_top_moves(number))

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


@app.route("/get-evaluation/", methods=["GET"])
def get_evaluation_page():
    """
    Retrieves the evaluation of a given FEN position using Stockfish.

    Returns:
        str: The evaluation of the FEN position.

    Raises:
        Exception: If there is an error in processing the request.

    """
    try:
        fen = str(request.args.get("fen"))
        stockfish.set_fen_position(fen)
        return str(stockfish.get_evaluation())

    except Exception as e:
        app.logger.error(str(e))
        return jsonify({"error": "Erroneous input"}), 400


def main():
    """
    This function starts the server and prints the start and end time of the server.
    """
    print(time.asctime(time.localtime(time.time())) + ": Starting server...")
    app.run(port=7777)
    print(time.asctime(time.localtime(time.time())) + ": Server started!")


# Run as admin
if __name__ == "__main__":
    if not pyuac.isUserAdmin():
        print("Re-launching as admin!")
        pyuac.runAsAdmin()
    else:
        main()

# How to start
"""Fire it up: ngrok http 7777"""

# how to access from computer
"""

import requests
url = "https://c6a4-173-63-234-100.ngrok-free.app/"
headers = {
    "ngrok-skip-browser-warning": "true"
}

response = requests.get(url, headers=headers)
# Do something with the response
print(response.text)

"""