Secret Santa Generator | Python Fiddle

#!/usr/bin/env python

from random import shuffle

book_club = [
        { "name": "David",   "group": 1 },
        { "name": "Laura",   "group": 1 },
        { "name": "Travis",  "group": 2 },
        { "name": "Mandy",   "group": 2 },
        { "name": "Giddeon", "group": 3 },
        { "name": "Devon",   "group": 3 },
        { "name": "Beth",    "group": 3 },
        { "name": "Noah",    "group": 4 },
        { "name": "Matt",    "group": 5 },
        { "name": "Forest",  "group": 6 },
    ]

def graph_from(people):
    g = Graph()

for i in range(0, len(people)):
        person = people[i]
        nodelist = []

for j in range(0, len(people)):
            target = people[j]
            if i != j and person['group'] != target['group']:
                nodelist = nodelist + [j]

g.add(i, person['name'], nodelist)

return g

class Vertex(object):
    def __init__(self, node, name, nodelist):
        self.i = node
        self.name = name
        self.nodelist = nodelist

def __hash__(self):
        return self.i

def reaches(self, vertex):
        if isinstance(vertex, int):
            return vertex in self.nodelist
        
        return self.reaches(vertex.i)

def __str__(self):
        return self.name

def __repr__(self):
        return self.__str__()

class Graph(object):
    def __init__(self):
        self.vlist = {}

def add(self, node, name, *nodelist):
        vertex = Vertex(node, name, *nodelist)
        self.vlist[node] = vertex

def hamiltonian(self, current=None, pending=None, destiny=None):
        if pending is None:
            pending = self.vlist.values()

result = None

if current is None:
            for current in pending:
                result = self.hamiltonian(current, [x for x in pending if x is not current], current)
                if result is not None:
                    break
        else:
            if pending == []:
                if current.reaches(destiny):
                    return [current]
                else:
                    return None

for x in [self.vlist[v] for v in current.nodelist]:
                if x in pending:
                    result = self.hamiltonian(x, [y for y in pending if y is not x], destiny)
                    if result is not None:
                        result = [current] + result
                        break

return result

if __name__ == '__main__':
    shuffle(book_club)
    G = graph_from(book_club)
    order = G.hamiltonian()
    assignments = zip(order, order[1:]+[order[0]])
    print assignments

Python Fiddle

Python Cloud IDE