def create_all_solved_boards_async():
"""Starts a search for all the solutions for a given board.
---
post:
tags:
- Solved Boards
summary: Starts a search for all the solutions for a given board
(may take a while).
requestBody:
description: The board to be solved and the max. number of solutions to return.
required: true
content:
application/json:
schema: SolveAllSchema
responses:
202:
description: The search has been started. The url for querying the
search progress is returned in the "location" header
of the response.
400:
description: Error detail in "message".
"""
global job_info
global job_info_lock
board = lsdk.Board()
try:
body = request.get_json()
board = lsdk.Board(body["board"]) # Board to solve
max_solutions = body["maxSolutions"]
except Exception as e:
raise (InvalidUsage("Bad request: {}".format(str(e)), 400))
executor = get_executor()
# Invokes the solving worker giving a unique id to index the
# corresponding future. This unique id will then be passed to the
# solving status endpoint so it knows which future to query.
location_value = ""
current_job_id = str(uuid.uuid4())
with job_info_lock:
info = {"progress_percent": 0.0, "num_solutions": 0, "cancel": False}
job_info[current_job_id] = info
executor.submit_stored(current_job_id, solve_board_worker, board,
max_solutions, current_job_id)
location_value = url_for('api.get_solve_status', job_id=current_job_id)
response = current_app.response_class(status=202)
response.headers["Location"] = location_value
return response
def get_board_status():
"""Retrieves the status of a given board (the board goes in JSON format in the body).
---
post:
tags:
- Boards
summary: Retrieves the status of a given board.
requestBody:
description: The board to be evaluated
required: true
content:
application/json:
schema: BoardSchema
responses:
200:
description: The status of the board.
content:
application/json:
schema: BoardStatusSchema
400:
description: Error detail in "message".
"""
try:
body = request.get_json()
b = lsdk.Board(body["board"])
invalid_positions = b.getInvalidPositions()
d = {
"isValid": b.isValid,
"isEmpty": b.isEmpty,
"isComplete": b.isComplete,
"invalidPositions": [(p[0], p[1]) for p in invalid_positions]
}
return jsonify(d)
except Exception as e:
raise (InvalidUsage("Bad request: {}".format(str(e)), 400))
def create_one_solved_board():
"""Finds one solution for a given board (if possible).
---
post:
tags:
- Solved Boards
summary: Returns one solution for a given board.
requestBody:
description: The board to be solved
required: true
content:
application/json:
schema: BoardSchema
responses:
200:
description: A solution for the given board
content:
application/json:
schema: SolvedBoardSchema
400:
description: Error detail in "message".
"""
s = lsdk.Board() # Board to hold the solution
result = lsdk.SolverResult.NO_ERROR
try:
body = request.get_json()
b = lsdk.Board(body["board"]) # Board to solve
solver = lsdk.Solver()
result = solver.solve(b, s)
except Exception as e:
raise (InvalidUsage("Bad request: {}".format(str(e)), 400))
if result == lsdk.SolverResult.NO_ERROR:
return jsonify({"board": [v for v in s]})
else:
raise (InvalidUsage("Not solvable: {}".format(result), 400))
def gen_board_worker(difficulty_level):
"""Generates a board with the given difficulty_level.
Returns a dictionary with the following keys:
. "gen_result": one of the values of GeneratorResult
. "gen_board": the generated board if any
. "start_time"
. "finish_time"
"""
start_time = time.time()
gen_board = lsdk.Board()
gen_result = lsdk.GeneratorResult.NO_ERROR
gen = lsdk.Generator()
asyncGenCompleted = False
# Handler for generation finished: captures the results.
def on_gen_finished(result, board):
nonlocal asyncGenCompleted
asyncGenCompleted = True
nonlocal gen_result
gen_result = result
nonlocal gen_board
gen_board = board
gen.asyncGenerate(
difficulty_level,
None, # Does nothing on progress
on_gen_finished)
while not asyncGenCompleted:
time.sleep(0.1)
finish_time = time.time()
# Set future result
fut_result = {
# GenerationResult is not JSON serializable.
# That's the reason for the str explicit conversion.
"status": str(gen_result),
# Board is not JSON serializable.
# That's the reason for the list compreheension
"board": [val for val in gen_board],
"gen_time": finish_time - start_time
}
return fut_result
import py_libsudoku as lsdk
import time
asyncGenComplete = False
genBoard = lsdk.Board()
def onGenProgress(currentStep, totalSteps):
print(" .... asyncGenerate at step {} of {}".format(
currentStep, totalSteps))
def onGenFinished(result, board):
global genBoard
genBoard = board
global asyncGenComplete
asyncGenComplete = True
print()
print(".... asyncGenerate finished: {}".format(result))
gen = lsdk.Generator()
print("Will generate board with Hard difficulty ...")
gen.asyncGenerate(lsdk.PuzzleDifficulty.HARD, onGenProgress, onGenFinished)
while not asyncGenComplete:
time.sleep(0.1)
print("Generated board: {}".format(genBoard))
import py_libsudoku
clear_board = py_libsudoku.Board()
print("clear_board = {}".format(clear_board))
print("Is clear_board empty? {}".format(clear_board.isEmpty))
print("Is clear_board valid? {}".format(clear_board.isValid))
print("Is clear_board complete? {}".format(clear_board.isComplete))
print()
print()
one_to_nine = py_libsudoku.Board([1, 2, 3, 4, 5, 6, 7, 8, 9])
print("one_to_nine = {}".format(one_to_nine))
print("Is one_to_nine valid? {}".format(one_to_nine.isValid))
print()
print()
one_to_nine_cpy = py_libsudoku.Board(one_to_nine)
print("one_to_nine_cpy = {}".format(one_to_nine_cpy))
print("Is one_to_nine equal to its copy? {}".format(
one_to_nine == one_to_nine_cpy))
def onSolverFinished(result, solvedBoards):
global asyncSolveComplete
asyncSolveComplete = True
print()
print("asyncSolveForGood finished: {}".format(result))
print("Found {} solution(s):".format(len(solvedBoards)))
for b in solvedBoards:
print()
print("{}".format(b))
solvable_one_solution = lsk.Board([
0, 0, 6, 0, 0, 8, 5, 0, 0, 0, 0, 0, 0, 7, 0, 6, 1, 3, 0, 0, 0, 0, 0, 0, 0,
0, 9, 0, 0, 0, 0, 9, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 8, 0, 0, 4, 0, 0, 5, 3,
0, 0, 0, 0, 1, 0, 7, 0, 5, 3, 0, 0, 0, 0, 5, 0, 0, 6, 4, 0, 0, 0, 3, 0, 0,
1, 0, 0, 0, 6, 0
])
solution = lsk.Board()
solver = lsk.Solver()
print("Board to be solved - 'solvable_one_solution': {}".format(
solvable_one_solution))
print("Looking for solution ...")
result = solver.solve(solvable_one_solution, solution)
if result == lsk.SolverResult.NO_ERROR:
print("... solution found: {}".format(solution))