Fix review

.gitignore

@@ -1,6 +1,14 @@
-# Ignore system files
-.DS_Store
-Thumbs.db
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
 
-# Ignore Python virtual environment
+# Virtual environment
 .venv/
+
+# VS Code
+.vscode/
+
+# OS files
+.DS_Store
+Thumbs.db

README.md

@@ -58,3 +58,131 @@ Use GitHub Copilot to refactor the code for this game to add more advanced featu
 - The game should be responsive and work well on both desktop and mobile devices.
 - UI colors should be visually appealing and accessible.
 - Completed and correct puzzles should display a congratulatory message with the time taken and hints used and ask for the user's name for Top 10 times.
+
+
+# Sudoku Game (Flask)
+
+A web-based Sudoku game built using Python Flask. The project was refactored into a modular architecture using GitHub Copilot while preserving the original functionality.
+
+## Features
+
+- Generate random Sudoku puzzles
+- Three difficulty levels (Easy, Medium, Hard)
+- Sudoku solver
+- Hint system
+- Check solution
+- Game timer
+- Top 10 leaderboard
+- Dark mode
+- Responsive UI
+- Unique-solution puzzle generation
+- Automated testing with Pytest
+
+## Project Structure
+
+```
+starter/
+│── app.py
+│── board.py
+│── validator.py
+│── solver.py
+│── generator.py
+│── sudoku_logic.py
+│── static/
+│── templates/
+│── tests/
+```
+
+## Installation
+
+Clone the repository.
+
+```bash
+git clone https://github.com/vuppalapati09/github-copilot-python.git
+```
+
+Move into the project.
+
+```bash
+cd github-copilot-python/starter
+```
+
+Create a virtual environment.
+
+```bash
+python -m venv .venv
+```
+
+Activate it.
+
+Windows PowerShell:
+
+```powershell
+.\.venv\Scripts\Activate.ps1
+```
+
+Install dependencies.
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run the Application
+
+```bash
+python app.py
+```
+
+Open:
+
+```
+http://127.0.0.1:5000
+```
+
+## Run Tests
+
+```bash
+pytest -q
+```
+
+All tests should pass successfully.
+
+## Refactoring Summary
+
+The application was refactored into separate modules:
+
+- board.py
+- validator.py
+- solver.py
+- generator.py
+
+The original functionality was preserved while improving readability and maintainability.
+
+## Screenshots
+
+### Final Application
+
+![Final UI](starter/screenshots/final_ui.png)
+
+### Copilot Refactoring
+
+![Copilot Refactor](starter/screenshots/copilot_refactor.png)
+
+### Testing Framework
+
+![Testing](starter/screenshots/copilot_testing_framework.png)
+
+## Technologies Used
+
+- Python
+- Flask
+- HTML
+- CSS
+- JavaScript
+- Pytest
+- Git
+- GitHub Copilot
+
+## Author
+
+Vuppalapati Surya prakash

starter/app.py

@@ -9,13 +9,30 @@
     'solution': None
 }
 
+
+def get_clues_for_difficulty(difficulty):
+    difficulty_map = {
+        'easy': 45,
+        'medium': 35,
+        'hard': 25,
+    }
+    if difficulty is None:
+        return difficulty_map['medium']
+    normalized = difficulty.lower()
+    return difficulty_map.get(normalized, difficulty_map['medium'])
+
+
 @app.route('/')
 def index():
     return render_template('index.html')
 
 @app.route('/new')
 def new_game():
-    clues = int(request.args.get('clues', 35))
+    clue_arg = request.args.get('clues')
+    if clue_arg is not None:
+        clues = int(clue_arg)
+    else:
+        clues = get_clues_for_difficulty(request.args.get('difficulty'))
     puzzle, solution = sudoku_logic.generate_puzzle(clues)
     CURRENT['puzzle'] = puzzle
     CURRENT['solution'] = solution
@@ -33,7 +50,25 @@ def check_solution():
         for j in range(sudoku_logic.SIZE):
             if board[i][j] != solution[i][j]:
                 incorrect.append([i, j])
-    return jsonify({'incorrect': incorrect})
+    completed = len(incorrect) == 0
+    return jsonify({'incorrect': incorrect, 'completed': completed})
+
+
+@app.route('/hint', methods=['POST'])
+def provide_hint():
+    data = request.json
+    board = data.get('board')
+    solution = CURRENT.get('solution')
+    if solution is None:
+        return jsonify({'error': 'No game in progress'}), 400
+
+    for i in range(sudoku_logic.SIZE):
+        for j in range(sudoku_logic.SIZE):
+            if board[i][j] == 0:
+                return jsonify({'row': i, 'col': j, 'value': solution[i][j]})
+
+    return jsonify({'error': 'No empty cells left'}), 400
+
 
 if __name__ == '__main__':
     app.run(debug=True)

starter/board.py

@@ -0,0 +1,12 @@
+import copy
+
+SIZE = 9
+EMPTY = 0
+
+
+def deep_copy(board):
+    return copy.deepcopy(board)
+
+
+def create_empty_board():
+    return [[EMPTY for _ in range(SIZE)] for _ in range(SIZE)]

starter/generator.py

@@ -0,0 +1,64 @@
+from board import EMPTY, SIZE, create_empty_board, deep_copy
+from solver import fill_board
+from validator import is_safe
+
+
+def remove_cells(board, clues):
+    import random
+
+    attempts = SIZE * SIZE - clues
+    while attempts > 0:
+        row = random.randrange(SIZE)
+        col = random.randrange(SIZE)
+        if board[row][col] != EMPTY:
+            board[row][col] = EMPTY
+            attempts -= 1
+
+
+def count_solutions(board, limit=2):
+    board_copy = deep_copy(board)
+    solutions = 0
+
+    def search(state):
+        nonlocal solutions
+
+        if solutions >= limit:
+            return
+
+        next_empty = None
+        for row in range(SIZE):
+            for col in range(SIZE):
+                if state[row][col] == EMPTY:
+                    next_empty = (row, col)
+                    break
+            if next_empty is not None:
+                break
+
+        if next_empty is None:
+            solutions += 1
+            return
+
+        row, col = next_empty
+        for candidate in range(1, SIZE + 1):
+            if not is_safe(state, row, col, candidate):
+                continue
+            state[row][col] = candidate
+            search(state)
+            if solutions >= limit:
+                state[row][col] = EMPTY
+                return
+            state[row][col] = EMPTY
+
+    search(board_copy)
+    return solutions
+
+
+def generate_puzzle(clues=35):
+    while True:
+        board = create_empty_board()
+        fill_board(board)
+        solution = deep_copy(board)
+        remove_cells(board, clues)
+        puzzle = deep_copy(board)
+        if count_solutions(puzzle, limit=2) == 1:
+            return puzzle, solution

starter/instruction.md

@@ -0,0 +1,31 @@
+# GitHub Copilot Instructions
+
+## Project Goal
+
+Refactor the Flask Sudoku application into a clean, modular, and maintainable project while preserving existing functionality.
+
+## Python Guidelines
+
+- Follow PEP 8.
+- Use descriptive variable and function names.
+- Keep functions small and reusable.
+- Avoid duplicate code.
+- Add type hints where appropriate.
+
+## Flask Guidelines
+
+- Keep routes thin.
+- Move business logic outside app.py.
+- Separate UI from game logic.
+
+## Testing
+
+- Run pytest after every major change.
+- Preserve all existing functionality.
+- Do not introduce breaking changes.
+
+## Refactoring
+
+- Perform small incremental refactoring.
+- Preserve backward compatibility.
+- Keep public function names unchanged.

starter/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = .

starter/requirements.txt

@@ -1 +1,2 @@
 Flask>=2.0
+pytest>=8.0

starter/solver.py

@@ -0,0 +1,20 @@
+import random
+
+from board import EMPTY, SIZE
+from validator import is_safe
+
+
+def fill_board(board):
+    for row in range(SIZE):
+        for col in range(SIZE):
+            if board[row][col] == EMPTY:
+                possible = list(range(1, SIZE + 1))
+                random.shuffle(possible)
+                for candidate in possible:
+                    if is_safe(board, row, col, candidate):
+                        board[row][col] = candidate
+                        if fill_board(board):
+                            return True
+                        board[row][col] = EMPTY
+                return False
+    return True