Word search generator in Python: the two bugs a quick one ships

import random

DIRS = {"easy": [(0, 1), (1, 0)],                                   # right, down
        "medium": [(0, 1), (1, 0), (1, 1), (-1, 1)],                # + two diagonals
        "hard": [(0, 1), (1, 0), (1, 1), (-1, 1), (0, -1), (-1, 0), (-1, -1), (1, -1)]}   # all 8, backwards too
# English letter frequencies: filler that looks like a real puzzle, not alphabet soup
FREQ = "EEEEEEEEEEEETTTTTTTTTAAAAAAAAOOOOOOOIIIIIIINNNNNNNSSSSSSHHHHHHRRRRRRDDDDLLLLCCCUUUMMMWWFFGGYYPPBVKJXQZ"

def clashes(words):
    """Pairs that can never read exactly once: PEAR inside PEARL, or RAT backwards inside STAR."""
    return [(a, b) for a in words for b in words if a != b and (a in b or a[::-1] in b)]

def place(words, size, dirs, rng, tries=300):
    """Longest words first, each at a random spot where it fits (crossing on the same letter is fine)."""
    grid, where = [[None] * size for _ in range(size)], {}
    for w in sorted(words, key=len, reverse=True):
        for _ in range(tries):
            dr, dc = rng.choice(dirs)
            r, c = rng.randrange(size), rng.randrange(size)
            cells = [(r + dr * i, c + dc * i) for i in range(len(w))]
            if all(0 <= y < size and 0 <= x < size and grid[y][x] in (None, ch) for (y, x), ch in zip(cells, w)):
                for (y, x), ch in zip(cells, w):
                    grid[y][x] = ch
                where[w] = cells
                break
        else:
            return None, None                                       # start again with another seed
    return grid, where

def lines(size):
    """Every full straight line of the grid, in all 8 directions, as a list of cells."""
    out = []
    for dr, dc in [(0, 1), (1, 0), (1, 1), (-1, 1)]:
        for r in range(size):
            for c in range(size):
                if 0 <= r - dr < size and 0 <= c - dc < size:
                    continue                                        # not where a line starts
                cells, y, x = [], r, c
                while 0 <= y < size and 0 <= x < size:
                    cells.append((y, x))
                    y, x = y + dr, x + dc
                out += [cells, cells[::-1]]
    return out

def read(grid, all_lines):
    return [(cells, "".join(grid[y][x] for y, x in cells)) for cells in all_lines]

def find_all(texts, word):
    """Every place the word reads, whatever the level: a solver looks in all 8 directions."""
    hits = set()
    for cells, text in texts:
        i = text.find(word)
        while i >= 0:
            hits.add(frozenset(cells[i:i + len(word)]))
            i = text.find(word, i + 1)
    return hits

def fill(grid, where, blocked, rng, letters=FREQ, rounds=1000):
    """Fill the empty cells again until every listed word reads exactly once and no blocked word
    shows anywhere except inside a listed word (CLASS may hold ASS; the filler may not).
    Returns how many fills it took, or None when the placed words alone spell the problem."""
    size, all_lines = len(grid), lines(len(grid))
    empty = [(y, x) for y in range(size) for x in range(size) if grid[y][x] is None]
    words = [frozenset(cells) for cells in where.values()]
    placed = frozenset().union(*words)
    for n in range(1, rounds + 1):
        for y, x in empty:
            grid[y][x] = rng.choice(letters)
        texts = read(grid, all_lines)
        bad = [h for w, cells in where.items() for h in find_all(texts, w) if h != frozenset(cells)]
        bad += [h for b in blocked for h in find_all(texts, b) if not any(h <= w for w in words)]
        if not bad:
            return n
        if any(h <= placed for h in bad):
            return None                     # no refill can change placed letters: place the words again
    return None

def make(words, size, level, blocked, rng, attempts=100):
    """A clean grid: place, fill, and place again when the placement itself is the problem."""
    assert not clashes(words), clashes(words)
    for attempt in range(1, attempts + 1):
        grid, where = place(words, size, DIRS[level], rng)
        if grid and fill(grid, where, blocked, rng):
            return grid, where
    raise RuntimeError("no clean grid: use fewer or shorter words, or a bigger grid")

rng = random.Random(42)
words = ["APPLE", "BANANA", "CHERRY", "GRAPE", "LEMON", "MANGO", "MELON", "OLIVE", "PEACH", "PEAR",
         "PLUM", "LIME", "KIWI", "GUAVA", "PAPAYA", "APRICOT", "FIG", "DATE", "QUINCE", "BERRY"]
grid, where = make(words, 15, "hard", BLOCKED, rng)
print("\n".join(" ".join(row) for row in grid))