def get_filelist_dict(self, face_list):
        """ Parse list of face images into a filelist dictionary
         
        Inputs:
            face_list -- a list of paths to face images (list) 
        
        Outputs:
            filelists_dict -- a dictionary of image paths organized by category (dict)
        """
    # -- Organize images into the appropriate categories
        cats = {}
        for f in face_list:
            cat = "/".join(f.split('/')[:-1])
            name = f.split('/')[-1]
            if cat not in cats:
                cats[cat] = [name]
            else:
                cats[cat] += [name]

                
        # -- Shuffle the images into a new random order
        filelists_dict = {}
        seed = 1
        for cat in cats:
            filelist = cats[cat]
            if self._rand_gallery:
                random.seed(seed)
                random.shuffle(filelist)
                seed += 1
            filelist = [ cat + '/' + f for f in filelist ]
            filelists_dict[cat] = filelist
            
        return filelists_dict

 def select():
     cnt = 2
     sum_fit = sum([fitness(ind) for ind in population])
     pop = population[:]
     random.shuffle(pop)
     pairs = []
     for i in range(cnt):
         n = random.uniform(0, sum_fit)
         m = random.uniform(0, sum_fit)
         tmp_sum = 0
         first, second = None, None
         for ind in pop:
             tmp_sum += fitness(ind)
             if tmp_sum >= n:
                 first = ind
                 break
         tmp_sum = 0
         for ind in pop:
             tmp_sum += fitness(ind)
             if tmp_sum >= m:
                 second = ind
                 break
         if first is None or second is None:
             print("FAILED")
             raise RuntimeError("Ooops")
         pairs.append((first, second))
     print(str(pairs))
     return pairs

    def test03_ThreadedTransactions(self):
        if verbose:
            print('\n', '-=' * 30)
            print("Running %s.test03_ThreadedTransactions..." % \
                  self.__class__.__name__)

        keys=list(range(self.records))
        import random
        random.shuffle(keys)
        records_per_writer=self.records//self.writers
        readers_per_writer=self.readers//self.writers
        self.assertEqual(self.records,self.writers*records_per_writer)
        self.assertEqual(self.readers,self.writers*readers_per_writer)
        self.assertTrue((records_per_writer%readers_per_writer)==0)

        readers=[]
        for x in range(self.readers):
            rt = Thread(target = self.readerThread,
                        args = (self.d, x),
                        name = 'reader %d' % x,
                        )#verbose = verbose)
            if sys.version_info[0] < 3 :
                rt.setDaemon(True)
            else :
                rt.daemon = True
            readers.append(rt)

        writers = []
        for x in range(self.writers):
            a=keys[records_per_writer*x:records_per_writer*(x+1)]
            b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
            wt = Thread(target = self.writerThread,
                        args = (self.d, a, b),
                        name = 'writer %d' % x,
                        )#verbose = verbose)
            writers.append(wt)

        dt = Thread(target = self.deadlockThread)
        if sys.version_info[0] < 3 :
            dt.setDaemon(True)
        else :
            dt.daemon = True
        dt.start()

        for t in writers:
            if sys.version_info[0] < 3 :
                t.setDaemon(True)
            else :
                t.daemon = True
            t.start()

        for t in writers:
            t.join()
        for t in readers:
            t.join()

        self.doLockDetect = False
        dt.join()

def generate_ids(number_objects):
    '''
    Generate 'number_objects' IDs
    '''
    from numpy import arange,random
    N = number_objects
    ids = arange(1,2*N)
    random.shuffle(ids)
    return ids[:N]

 def create_game(self, player_1_username, player_2_username):
     u"""
     Create a new game with the black and white player determined at random.
     """
     # The default Mersenne Twister random should be sufficient for this
     players = [player_1_username, player_2_username]
     random.shuffle(players)
     game_model = self.create(white_player=players[0], black_player=players[1])
     return game_model

    def test01_1WriterMultiReaders(self):
        if verbose:
            print '\n', '-=' * 30
            print "Running %s.test01_1WriterMultiReaders..." % \
                  self.__class__.__name__

        keys=range(self.records)
        import random
        random.shuffle(keys)
        records_per_writer=self.records//self.writers
        readers_per_writer=self.readers//self.writers
        self.assertEqual(self.records,self.writers*records_per_writer)
        self.assertEqual(self.readers,self.writers*readers_per_writer)
        self.assertTrue((records_per_writer%readers_per_writer)==0)
        readers = []

        for x in xrange(self.readers):
            rt = Thread(target = self.readerThread,
                        args = (self.d, x),
                        name = 'reader %d' % x,
                        )#verbose = verbose)
            import sys
            if sys.version_info[0] < 3 :
                rt.setDaemon(True)
            else :
                rt.daemon = True
            readers.append(rt)

        writers=[]
        for x in xrange(self.writers):
            a=keys[records_per_writer*x:records_per_writer*(x+1)]
            a.sort()  # Generate conflicts
            b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
            wt = Thread(target = self.writerThread,
                        args = (self.d, a, b),
                        name = 'writer %d' % x,
                        )#verbose = verbose)
            writers.append(wt)

        for t in writers:
            import sys
            if sys.version_info[0] < 3 :
                t.setDaemon(True)
            else :
                t.daemon = True
            t.start()

        for t in writers:
            t.join()
        for t in readers:
            t.join()

def staircaseFunctionEvolve(length, numSteps, order, delta, sigma, probMutation, probCrossover, popSize, maxGens):
    L = arange(length)
    random.shuffle(L)
    L=L[:order*numSteps]
    L.shape=(-1,order)
    V=ones(L.shape, dtype='int8')
    evolve(partial(staircaseFunction, L=L, V=V, delta=delta, sigma=sigma),
        length,
        popSize,
        maxGens,
        probMutation,
        probCrossover=probCrossover,
        visualizeGen=partial(staircaseFunctionVisualize,L=L, figNum=3),
        visualizeRun=partial(visualizeRun, figNum=4))

    def test02_SimpleLocks(self):
        if verbose:
            print "\n", "-=" * 30
            print "Running %s.test02_SimpleLocks..." % self.__class__.__name__
        keys = range(self.records)
        import random

        random.shuffle(keys)
        records_per_writer = self.records // self.writers
        readers_per_writer = self.readers // self.writers
        self.assertEqual(self.records, self.writers * records_per_writer)
        self.assertEqual(self.readers, self.writers * readers_per_writer)
        self.assertTrue(records_per_writer % readers_per_writer == 0)
        readers = []
        for x in xrange(self.readers):
            rt = Thread(target=self.readerThread, args=(self.d, x), name="reader %d" % x)
            if sys.version_info[0] < 3:
                rt.setDaemon(True)
            else:
                rt.daemon = True
            readers.append(rt)

        writers = []
        for x in xrange(self.writers):
            a = keys[records_per_writer * x : records_per_writer * (x + 1)]
            a.sort()
            b = readers[readers_per_writer * x : readers_per_writer * (x + 1)]
            wt = Thread(target=self.writerThread, args=(self.d, a, b), name="writer %d" % x)
            writers.append(wt)

        for t in writers:
            if sys.version_info[0] < 3:
                t.setDaemon(True)
            else:
                t.daemon = True
            t.start()

        for t in writers:
            t.join()

        for t in readers:
            t.join()

def evolve(fitnessFunction,
            length,
            popSize,
            maxGens,
            probMutation,
            probCrossover=1,
            sigmaScaling=True,
            sigmaScalingCoeff=1,
            SUS=True,
            visualizeGen=visualizeGen,
            visualizeRun=visualizeRun):

    maskReposFactor = 5
    uniformCrossoverMaskRepos = rand(popSize/2, (length+1)*maskReposFactor) < 0.5
    mutMaskRepos = rand(popSize, (length+1)*maskReposFactor) < probMutation

    avgFitnessHist = zeros(maxGens+1)
    maxFitnessHist = zeros(maxGens+1)

    pop = zeros((popSize, length), dtype='int8')
    pop[rand(popSize, length)<0.5] = 1

    for gen in xrange(maxGens):

        fitnessVals = fitnessFunction(pop)
        fitnessVals = transpose(fitnessVals)
        maxFitnessHist[gen] = fitnessVals.max()
        avgFitnessHist[gen] = fitnessVals.mean()

        print "gen = %.3d   avgFitness = %3.3f  maxfitness = %3.3f" % (gen, avgFitnessHist[gen], maxFitnessHist[gen])
        if visualizeGen:
            visualizeGen(pop, gen=gen, avgFitness=avgFitnessHist[gen], maxFitness=maxFitnessHist[gen])
        if sigmaScaling:
            sigma = std(fitnessVals)
            if sigma:
                fitnessVals = 1 + (fitnessVals - fitnessVals.mean()) / (sigmaScalingCoeff * sigma)
                fitnessVals[fitnessVals<0] = 0
            else:
                fitnessVals = ones(1,popSize)

        cumNormFitnessVals = cumsum(fitnessVals/fitnessVals.sum())
        if SUS:
            markers = random.random() + arange(popSize,dtype='float')/popSize
            markers[markers>1] = markers[markers >1] - 1
        else:
            markers = rand(1, popSize)
        markers = sort(markers)
        parentIndices = zeros(popSize, dtype='int16')
        ctr = 0
        for idx in xrange(popSize):
            while markers[idx]>cumNormFitnessVals[ctr]:
                ctr += 1
            parentIndices[idx] = ctr
        random.shuffle(parentIndices)

        # deterimine the first parents of each mating pair
        firstParents = pop[parentIndices[0:popSize/2],:]
        # determine the second parents of each mating pair
        secondParents = pop[parentIndices[popSize/2:],:]

        temp = floor(random.random() * length * maskReposFactor-1)
        masks = uniformCrossoverMaskRepos[:, temp:temp+length]
        reprodIndices = rand(popSize/2)<1-probCrossover
        masks[reprodIndices, :] = False
        firstKids = firstParents
        firstKids[masks] = secondParents[masks]
        secondKids = secondParents
        secondKids[masks] = firstParents[masks]
        pop = vstack((firstKids, secondKids))

        temp = floor(random.random()*length*(maskReposFactor-1))
        masks = mutMaskRepos[:, temp:temp+length]
        pop[masks] = pop[masks] + 1
        pop = remainder(pop, 2)

    visualizeRun(avgFitnessHist, maxFitnessHist)

def _generate_vals(count, token):
    random.seed(token)
    return random.shuffle([1 for __ in range(count // 2)] + [-1 for __ in range(count // 2)])

 def _randomize(self, iteration):
     random.shuffle(self._expressions)
     return next(iter(self._expressions))

def process_all_in_random_order(data, process):
    data = list(data)
    random.shuffle(data)
    for elem in data:
        process(data)

def random_order(graph):
    l= graph.keys()
    random.shuffle(l)
    return l