Sure, here's a simple Sudoku puzzle generator in Python:

```python
import random

def generate_sudoku():
    # Initialize an empty 9x9 Sudoku grid
    grid = [[0 for _ in range(9)] for _ in range(9)]

    # Generate a valid Sudoku grid
    fill_grid(grid)

    # Remove numbers to create the puzzle
    remove_numbers(grid)

    return grid

def fill_grid(grid):
    for i in range(9):
        for j in range(9):
            # Try random numbers until a valid number is found
            while True:
                num = random.randint(1, 9)
                if is_valid(grid, i, j, num):
                    grid[i][j] = num
                    break

def is_valid(grid, row, col, num):
    # Check if the number is already in the same row or column
    for i in range(9):
        if grid[row][i] == num or grid[i][col] == num:
            return False

    # Check if the number is already in the same 3x3 subgrid
    start_row, start_col = 3 * (row // 3), 3 * (col // 3)
    for i in range(3):
        for j in range(3):
            if grid[start_row + i][start_col + j] == num:
                return False

    return True

def remove_numbers(grid):
    # Remove numbers from the filled grid to create the puzzle
    # The number of removed numbers can vary based on difficulty level
    # For simplicity, let's remove a fixed number of numbers
    num_to_remove = 45  # Adjust this number to change the difficulty level

    for _ in range(num_to_remove):
        # Choose a random cell that is not already empty
        while True:
            row = random.randint(0, 8)
            col = random.randint(0, 8)
            if grid[row][col] != 0:
                break

        # Temporarily store the cell value and set it to 0
        temp = grid[row][col]
        grid[row][col] = 0

        # Check if the puzzle still has a unique solution
        if not has_unique_solution(grid):
            # If not, revert the cell value and try again
            grid[row][col] = temp

def has_unique_solution(grid):
    # Check if the puzzle has a unique solution using backtracking
    # This function assumes that the current grid is solvable

    # Find the first empty cell in the grid
    for i in range(9):
        for j in range(9):
            if grid[i][j] == 0:
                # Try all numbers from 1 to 9
                for num in range(1, 10):
                    if is_valid(grid, i, j, num):
                        # Temporarily fill the cell with the number and check if the puzzle has a unique solution
                        grid[i][j] = num
                        if not has_unique_solution(grid):
                            # If multiple solutions are found, revert the cell value and return False
                            grid[i][j] = 0
                            return False
                        # If a unique solution is found, revert the cell value and continue searching
                        grid[i][j] = 0
                # If no valid number is found for the empty cell, the puzzle has multiple solutions
                return False
    # If no empty cells are found, the puzzle has a unique solution
    return True

def print_grid(grid):
    for row in grid:
        print(" ".join(map(str, row)))

# Example usage:
sudoku_grid = generate_sudoku()
print("Generated Sudoku puzzle:")
print_grid(sudoku_grid)
```

This code generates a Sudoku puzzle with a given difficulty level by removing a fixed number of numbers from a fully filled grid. You can adjust the difficulty level by changing the `num_to_remove` variable.