Let's Solve Cross Set

import sys
import cross_set

# Script must be run directly, not imported
if __name__ == '__main__':

    # Script requires one argument: filename
    if len(sys.argv) < 2:
        print("Filename argument required")
        sys.exit(1)

    # Filename is the first argument (sys.argv[0] is the program name)
    filename = sys.argv[1]

    # Read from the provided filename, assuming it exists
    puzzle_contents = ""
    with open(filename) as puzzle_file:
        puzzle_contents = puzzle_file.read()

    # Stuff the contents into puzzle (list of list of sets) with minimal validation
    puzzle = []
    # Each line: Add a list to puzzle
    for line in puzzle_contents.split('\n'):
        puzzle_line = []
        # Each cell: Add a set to puzzle_line
        for cell in line.split(' '):
            # Discard spaces used for alignment
            if cell == '':
                continue
            # Each number: Convert to an int before adding to the set
            cell_numbers = (int(x) for x in cell)
            puzzle_line.append(set(cell_numbers))
        puzzle.append(puzzle_line)

    puzzle_grid = cross_set.PuzzleGrid(puzzle)

    solved_grid = cross_set.solve(puzzle_grid)
    print(solved_grid)

import copy
import itertools

class PuzzleGrid(object)
    def __init__(self, puzzle):
        # Check that the provided grid is square
        num_rows = len(puzzle)

        for row in puzzle:
            if len(row) != num_rows:
                raise ValueError("Puzzle grid is not square")

        self.grid = copy.deepcopy(puzzle)

    def __str__(self):
        # Get the size of the largest set in the puzzle
        all_cells = (self.cell(x,y) for x,y in itertools.product(range(self.size()), range(self.size())))
        padding = max(len(cell) for cell in all_cells)
        rows = []
        for row in self.grid:
            cells = []
            for cell in row:
                # Print set(1,2,3) as 123, padding to the largest set in the puzzle
                format_str = "%% %ds" % padding
                compact_set = "".join(str(num) for num in cell)
                cells.append(format_str % compact_set)
            rows.append(" ".join(cells))
        return "\n".join(rows)

    def column(self, x):
        return (row[x] for row in self.grid)

    def row(self, y):
        return self.grid[y]

    def cell(self, x, y):
        return self.grid[y][x]

    def set_cell(self, x, y, val):
        self.grid[y][x] = val

    def size(self):
        return len(self.grid)

    def __eq__(self, other):
        return self.grid == other.grid

    def __ne__(self, other):
        return not (self == other)

puzzle_grid = cross_set.PuzzleGrid(puzzle)

cross_set.solve(puzzle_grid)
print(puzzle_grid)

from cross_set.puzzle_grid import PuzzleGrid

def cell_solved(cell):
    return len(cell) == 1

def list_solved(cell_list):
    # All cells have one value
    num_solved = sum(1 for cell in cell_list if cell_solved(cell))
    if num_solved < len(cell_list):
        return False

    # There are no duplicate cells
    cell_set = set(list(cell)[0] for cell in cell_list)
    if len(cell_set) < len(cell_list):
        return False

    return True

column_solved = list_solved
row_solved = list_solved

def puzzle_solved(puzzle):
    for row_num in range(puzzle.size()):
        if not row_solved(list(puzzle.row(row_num))):
            return False

    for col_num in range(puzzle.size()):
        if not column_solved(list(puzzle.column(col_num))):
            return False

    return True

def solve(puzzle):
    return PuzzleGrid(puzzle.grid)

# Remove invalidated cell values, this is the most basic thing to do to a puzzle
def weed(puzzle):
    old_puzzle = puzzle
    puzzle = PuzzleGrid(puzzle.grid)
    for row, column in itertools.product(range(puzzle.size()), range(puzzle.size())):
        cell = old_puzzle.cell(column, row)
        if cell_solved(cell):
            (locked_value,) = cell

            # Get a list of cells in the same row and column to weed
            in_row = ((c, row) for c in range(puzzle.size()) if not c == column)
            in_column = ((column, r) for r in range(puzzle.size()) if not r == row)
            cells_to_check = itertools.chain(in_row, in_column)

            # Read cells from the puzzle being modified and remove the locked value if it exists, saving off to the new puzzle
            for x,y in cells_to_check:
                other_cell = puzzle.cell(x, y)
                if locked_value in other_cell:
                    other_cell.remove(locked_value)

    return puzzle

def solve(puzzle):
    weeded_puzzle = weed(puzzle)

    while weeded_puzzle != puzzle:
        puzzle = weeded_puzzle
        weeded_puzzle = weed(puzzle)

    return puzzle

def minimal_form(puzzle):
    weeded_puzzle = weed(puzzle)
    while weeded_puzzle != puzzle:
        puzzle, weeded_puzzle = weeded_puzzle, weed(puzzle)
    return weeded_puzzle

# TODO: Get singles from old_puzzle, update them on puzzle
def lock_singles(puzzle):
    old_puzzle = puzzle
    puzzle = minimal_form(puzzle)

    rows = (puzzle.row(row) for row in range(puzzle.size()))
    columns = (puzzle.column(column) for column in range(puzzle.size()))
    # Take advantage of the fact these are all references and discard WHAT they are
    cell_lists = itertools.chain(rows, columns)
    for cell_list in cell_lists:
        values = []
        for cell in cell_list:
            values.extend(list(cell))

        singles = (i for i in range(1, puzzle.size()+1) if values.count(i) == 1)
        for single in singles:
            for cell in cell_list:
                if single in cell:
                    # Don't update already locked cells
                    if len(cell) > 1:
                        cell.intersection_update({single})
                    # It's a single for a reason, don't need to check the rest of the cells once it's found
                    continue

    return puzzle

def solve(puzzle):
    solved_puzzle = puzzle
    # Loop until there's no improvement
    while True:
        solved_puzzle = minimal_form(puzzle)
        solved_puzzle = lock_singles(solved_puzzle)

        if puzzle == solved_puzzle:
            break
        else:
            puzzle = solved_puzzle

    return solved_puzzle

def ntuple_equals(puzzle):
    old_puzzle = puzzle
    puzzle = minimal_form(puzzle)

    rows = (puzzle.row(row) for row in range(puzzle.size()))
    columns = (puzzle.column(column) for column in range(puzzle.size()))
    # Take advantage of the fact these are all references and discard WHAT they are
    cell_lists = itertools.chain(rows, columns)
    for cell_list in cell_lists:
        cell_list = list(cell_list)
        ntuples = []
        for cell in cell_list:
            if cell_list.count(cell) == len(cell) and cell not in ntuples:
                ntuples.append(cell)


        for tuple in ntuples:
            for cell in cell_list:
                if cell != tuple:
                    # Remove any elements from the tuple from cell
                    cell.difference_update(tuple)

    return puzzle

def solve(puzzle):
    solved_puzzle = puzzle
    # Loop until there's no improvement
    while True:
        solved_puzzle = minimal_form(puzzle)
        solved_puzzle = lock_singles(solved_puzzle)
        solved_puzzle = ntuple_equals(solved_puzzle)
        if puzzle == solved_puzzle:
            break
        else:
            puzzle = solved_puzzle

    return solved_puzzle

def sanity_check(puzzle):
    for row, column in itertools.product(range(puzzle.size()), range(puzzle.size())):
        cell = puzzle.cell(column, row)
        if len(cell) == 0:
            return False
    return True