## Let’s submit the model to Qaekwy

In the previous article, we have defined a generic Sudoku solver by defining the grid
and the distinct constraints for blocks, rows, columns, and future initial constant values.
Based on the previous definition of the model, you will learn how to instantiate our Sudoku
problem instance with values, to submit it to the `DirectEngine`

of Qaekwy, and to retrieve
the solution.

## Instantiate a grid

To instantiate a Sudoku grid, let’s take our `SudokuGrid`

defined in the previous article
and instantiate it with real values:

```
# Create a Sudoku grid with initial values. The values
# set to 0 represent the values to find. The other values
# are the constants.
my_grid = SudokuGrid(
grid_value=[
0, 7, 0, 0, 0, 0, 6, 9, 0,
0, 0, 0, 6, 1, 0, 0, 0, 0,
0, 9, 2, 0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 8, 1, 7, 0, 9,
4, 0, 0, 0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 5, 6, 1, 0, 8,
0, 5, 9, 0, 0, 0, 0, 1, 0,
0, 0, 0, 5, 6, 0, 0, 0, 0,
0, 2, 0, 0, 0, 0, 5, 7, 0
]
)
```

## Instantiate the problem

Now that your `SudokuGrid`

is ready, let’s instantiate the `SudokuProblem`

defined in the previous
article with the following code:

```
# Create a Sudoku problem instance using the grid
sp = SudokuProblem(grid=my_grid)
```

And that’s it. The `sp`

object represents the Sudoku problem instantiated with your Sudoku grid values.
Your Qaekwy model representing a Sudoku problem is now completed. Now, let’s solve this grid using the Qaekwy
engine.

## Instantiate the Qaekwy Engine

The *Engine* is the Qaekwy instance (a Cloud instance in our case) that will receive your model
to be solved, search for the solution(s) and return it to you. This Python library provides all the
methods for submitting a model to be solved to an instance and retrieving the solution.

There are three types of *Engine* (Cloud, stand-alone and Cloud/Cluster type). For tiny models,
including the model of this tutorial, the free-to-use Cloud instance is perfectly appropriate.

To communicate with the free-to-use Cloud instance, we need to instantiate the following
`DirectEngine`

object:

```
from qaekwy.engine import DirectEngine
qaekwy_engine = DirectEngine()
```

## Solve the problem

Now that we have:

- The problem instance
- The engine instance

Let’s submit the problem instance to the engine, retrieve, and display the solution using the following code:

```
# Request the Qaekwy engine to solve the Sudoku problem
response = qaekwy_engine.model(model=sp)
# Retrieve the list of solutions from the response
list_of_solutions = response.get_solutions()
# Print the solution obtained for the Sudoku puzzle
for solution_item in list_of_solutions:
for c in range(0, 81, 9):
print(solution_item.grid[c:c+9])
```

The output is the solution to our Sudoku problem:

```
[1, 7, 8, 3, 2, 5, 6, 9, 4]
[5, 4, 3, 6, 1, 9, 8, 2, 7]
[6, 9, 2, 7, 4, 8, 3, 5, 1]
[2, 6, 5, 4, 8, 1, 7, 3, 9]
[4, 8, 1, 9, 7, 3, 2, 6, 5]
[9, 3, 7, 2, 5, 6, 1, 4, 8]
[7, 5, 9, 8, 3, 2, 4, 1, 6]
[3, 1, 4, 5, 6, 7, 9, 8, 2]
[8, 2, 6, 1, 9, 4, 5, 7, 3]
```

## That’s it !

By using the Qaekwy Python Library for Sudoku problem definition, you can now apply the same model to solve diverse Sudoku grids, with the only variation being your dataset (in this case, the grid).

Indeed, the development of the Qaekwy Python library has been designed in order to
allow the developer to benefit from *Object-Oriented Programming* applied to constraint
programming design for solution research and optimization.