def find_neighbors(self,X):
     sys.stderr.write("\tFinding nearest neighbors...")
     for i in xrange(len(X)):
         progress(i)
         (_,ind) = self.neigh.kneighbors(X[i].reshape(1,-1))
         self.artists[i].predicted_similar = ind[0]
     sys.stderr.write("\n")

def base(d, player):
    code, tag = d.menu("Vous etes chez le marchand de bombes.",
                       choices=[("(1)", "Achetez un bombes"),
                                ("(2)", "Sortir du magasin"),
                                ("(3)", "Afficher mon inventaire")],
                       ok_label="Ok, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            if database.inventory.addToInventory(player, "bombe", 3):
                database.inventory.addToInventory(player, "or", -40)
                d.msgbox("Vous achetez 3 bombe, faites attention avec")
                return True
            else:
                d.msgbox("Vous n'avez pas assez d'or")
                return True
        elif tag == "(2)":
            progress(d, 15, "Vous sortez du magasin.", player)
            database.players.changePref(player, "location", "quartierCommercant")
            return True
        elif tag == "(3)":
            showInventory(d, player)
            return True

    else:
        return "pref"

def base(d, player):
    code, tag = d.menu("Vous etes au milieu du centre ville. il y a beaucoup de monde",
                       choices=[("(1)", "S'asseoir par terre"),
                                ("(2)", "Aller dans le quartier commerçant"),
                                ("(3)", "Aller au poste de police"),
                                ("(4)", "Aller au chateau"),
                                ("(5)", "Retourner à l'entrée de la ville")
                                ],
                       ok_label="OK, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            progress(d, 60, "Un policier vous prend pour un mendiant et vous envoie en prison", player)
            database.players.changePref(player, "location", "posteDePolice")
        elif tag == "(2)":
            progress(d, 15, "Vous allez au quartier commerçant", player)
            database.players.changePref(player, "location", "quartierCommercant")
            return True
        elif tag == "(3)":
            progress(d, 15, "Vous allez au poste de police", player)
            database.players.changePref(player, "location", "posteDePolice")
            return True
        elif tag == "(4)":
            progress(d, 15, "Vous allez au chateau", player)
            database.players.changePref(player, "location", "chateau")
            return True
        elif tag == "(5)":
            progress(d, 15, "Vous allez à l'entrée de la ville", player)
            database.players.changePref(player, "location", "villeDeNullepart")
            return True

    else:
        return "pref"

    def update_weights(self,X):

        sys.stderr.write("\tUpdating weights...")

        LAMBDA = 0.01

        for (i,artist) in enumerate(self.artists):
            progress(i)
            
            if len(artist.correct_similar) == 0:
                continue

            # this artist's features and current x vector
            features = self.m_features[artist._id]
            current_x = X[artist._id]

            # calculate the average x vector for similar artists
            avg_simil = np.average([X[simil_id] for simil_id in artist.correct_similar],axis=0)

            # determine ideal weights for this artist
            better_weights = self.np_divide(avg_simil,features)

            # and adjust self.weights by LAMBDA * (better_weights - self.weights)
            diff = np.subtract(better_weights,self.weights)
            adjust_by = np.multiply(diff,LAMBDA)
            self.weights = np.add(self.weights, adjust_by)

        sys.stderr.write("\n")

    def import_git_objects(self, remote_name=None, refs=None):
        convert_list, commits = self.getnewgitcommits(refs)
        # import each of the commits, oldest first
        total = len(commits)
        if total:
            self.ui.status(_("importing git objects into hg\n"))

        for i, csha in enumerate(commits):
            util.progress(self.ui, 'importing', i, total=total, unit='commits')
            commit = convert_list[csha]
            self.import_git_commit(commit)
        util.progress(self.ui, 'importing', None, total=total, unit='commits')

        # Remove any dangling tag references.
        for name, rev in self.repo.tags().items():
            if not rev in self.repo:
                if hasattr(self, 'tagscache') and self.tagscache and \
                        'name' in self.tagscache:
                    # Mercurial 1.4 and earlier.
                    del self.repo.tagscache[name]
                elif hasattr(self, '_tags') and self._tags and \
                        'name' in self._tags:
                    # Mercurial 1.5 and later.
                    del self.repo._tags[name]
                if name in self.repo._tagtypes:
                    del self.repo._tagtypes[name]

def base(d, player):
    code, tag = d.menu("Vous etes dans les quartiers pauvres de la ville.",
                       choices=[("(1)", "Aller dans les montagnes"),
                                ("(2)", "Aller dans la taverne."),
                                ("(3)", "Affronter des bandits(systeme de combat en cours de création)."),
                                ("(4)", "Retourner dans le quartier commerçant."),
                                ("(5)", "Afficher mon inventaire.")],
                       ok_label="Ok je veux faire ça",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            progress(d, 40, "Vous allez dans les montagnes.", player)
            database.players.changePref(player, "location", "montagne")
            return True
        elif tag == "(2)":
            progress(d, 15, "Vous rentrez dans la taverne.", player)
            database.players.changePref(player, "location", "taverne")
            return True
        elif tag == "(3)":
            progress(d, 20, "Vous vous aventurez dans la ville pour trouver des bandits", player)
            database.players.changePref(player, "location", "combatBandit")
            return True
        elif tag == "(4)":
            progress(d, 30, "Vous retournez dans le quartier commerçant.", player)
            database.players.changePref(player, "location", "quartierCommercant")
            return True
        elif tag == "(5)":
            showInventory(d, player)
            return True
    else:
        return "pref"

def base(d, player):
    code, tag = d.menu("Vous etes dans la pharmacie",
                       choices=[("(1)", "Acheter une potion de soin (15 or)"),
                                ("(2)", "Acheter du chocolay noir (10 or)"),
                                ("(3)", "Regarder les affiches de publicités"),
                                ("(4)", "Retourner dans le quartier"),
                                ("(5)", "Afficher mon inventaire")
                                ],
                       ok_label="Ok, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            if database.inventory.addToInventory(player, "or", -15):
                database.inventory.addToInventory(player, "potion", 1)
                d.msgbox("Vous avez acheté une potion de soin")
                return True
            else:
                d.msgbox("Vous n'avez pas assez d'or.")
        elif tag == "(2)":
            if database.inventory.addToInventory(player, "or", -15):
                database.inventory.addToInventory(player, "chocolat", 1)
                d.msgbox("Vous avez acheté du chocolat,")
                return True
            else:
                d.msgbox("Vous n'avez pas assez d'or.")
        elif tag == "(3)":
            code, tag = d.menu("Vous regardez les affiches",
                               choices=[("(1)", "Regarder l'affiche de droite"),
                                        ("(2)", "Regarder l'affiche de gauche")
                                        ],
                               ok_label="Regarder",
                               cancel_label="Ne pas regarder les affiches")
            if code == d.OK:
                if tag == "(1)":
                    d.msgbox("L'affiche est un publicité pour insectiside, le slogan est  \"bugs everywhere\".")
                elif tag == "(2)":
                    d.msgbox(
                        "L'affiche est celle d'unje société appelée Arperture Science Il y a un grand robot sur l'affiche qui s'appelle GlaDos")
            else:
                d.msgbox("Vous arrétez de regarder les affiches.")

        elif tag == "(4)":
            progress(d, 15, "Vous sortez du magasin", player)
            database.players.changePref(player, "location", "quartierCommercant")
            return True

        else:
            return "pref"

 def cmd_erase(self, ui, args):
   """erase flash"""
   # check for erase all
   if len(args) == 1 and args[0] == '*':
     ui.put('erase all: ')
     n_errors = self.driver.erase_all()
     ui.put('done (%d errors)\n' % n_errors)
     return
   # memory region erase
   x = util.mem_args(ui, args, self.device)
   if x is None:
     return
   (adr, n) = x
   if n is None:
     ui.put('bad erase length\n')
     return
   r = mem.region(None, adr, n)
   # build a list of regions to be erased
   erase_list = [x for x in self.driver.sector_list() if r.overlap(x)]
   if len(erase_list) == 0:
     ui.put('nothing to erase\n')
     return
   # do the erase
   ui.put('erasing : ')
   progress = util.progress(ui, 1, len(erase_list))
   n_erased = 0
   n_errors = 0
   for x in erase_list:
     n_errors += self.driver.erase(x)
     n_erased += 1
     progress.update(n_erased)
   progress.erase()
   ui.put('done (%d errors)\n' % n_errors)

    def _go(self):

        # Similarity matrix
        similar = zeros((self.N, self.N), float)

        for i in range(self.N):
            for j in range(self.N):
                similar[i][j] = -1

        #
        # Compute similarity matrix of SW scores
        #
        progress = 0
        for i in range(self.N):
            for j in range(self.N):

                if progress % (self.N * self.N / 100) == 0:
                    util.progress(100, float(progress) / (self.N * self.N) * 100)
                progress += 1

                if similar[i][j] >= 0:
                    continue

                seq1 = self.sequences[i][1]
                seq2 = self.sequences[j][1]

                (nseq1, nseq2, edits1, edits2, score, gaps) = \
                    align.SmithWaterman(seq1, seq2, self.smx, 0, 0)

                similar[i][j] = similar[j][i] = score

        util.progress(100,100)
        #
        # Compute distance matrix of SW scores
        #
        for i in range(self.N):
            for j in range(self.N):

                if self.dmx[i][j] >= 0:
                    continue

                #print similar[i][j], " ",similar[i][i]
                if similar[i][i] != 0:
                    self.dmx[i][j] = 1 - (similar[i][j] / similar[i][i])
                else:
                    self.dmx[i][j] = 1
                self.dmx[j][i] = self.dmx[i][j]

    def export_git_objects(self):
        self.ui.status(_("importing Hg objects into Git\n"))
        self.init_if_missing()

        nodes = [self.repo.lookup(n) for n in self.repo]
        export = [node for node in nodes if not hex(node) in self._map_hg]
        total = len(export)
        for i, rev in enumerate(export):
            util.progress(self.ui, 'import', i, total=total)
            ctx = self.repo.changectx(rev)
            state = ctx.extra().get('hg-git', None)
            if state == 'octopus':
                self.ui.debug("revision %d is a part "
                              "of octopus explosion\n" % ctx.rev())
                continue
            self.export_hg_commit(rev)
        util.progress(self.ui, 'import', None, total=total)

def base(d, player):
    code, tag = d.menu("Les policier vous ont enfermés dans la prison, mais le geôlier vous libère.",
                       choices=[("(1)", "Parler au geôlier"),
                                ("(2)", "Tenter de libérer les prisonniers"),
                                ("(3)", "Revenir a la ville"),
                                ("(4)", "Afficher mon inventaire")],
                       ok_label="Ok, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            d.msgbox("""C'est ici que nous gardons les criminels qui ont été arrétés.""")
            code, tag = d.menu("Que dire ?",
                               choices=[
                                   ("(1)", "Les criminels?"),
                                   ("(2)", "D'accord ,donc sans vous ce serait l'anarchie.")
                               ],
                               ok_label="Dire ça",
                               cancel_label="mettre fin à la conversation")
            if code == d.OK:
                if tag == "(1)":
                    d.msgbox("Oui, cette ville regorge de fripouille en tous genre. Alors faites attention.")
                elif tag == "(2)":
                    d.msgbox("ça fais plaisir de voir que la jeune génération respecte mon travail.")
            else:
                d.msgbox("vous dites au revoir au geôlier")

        elif tag == "(2)":
            r = database.inventory.addToInventory(player, "or", -150)
            if not r:
                progress(d, 200,
                         "Votre tentative est stoppée net par le geôlier qui vous enferme. Vous n'avez pas assez d'or pour écourter votre peine.", player)
            else:
                progress(d, 120,
                         "Vous tenter de libérer les prisonniers, mais le geôlier vous en empeche et vous arrète. Vous avez une amende de 50 pièce d'or", player)
            return True

        elif tag == "(3)":
            database.players.changePref(player, "location", "centreVille")
            return True

        elif tag == "(4)":
            showInventory(d, player)
            return True
    else:
        return "pref"

 def __init__(self, ui, msg, name, size, mode = 'le'):
   self.ui = ui
   self.f = open(name, 'wb')
   self.n = 0
   self.fmt16 = ('>H', '<H')[mode == 'le']
   self.fmt32 = ('>L', '<L')[mode == 'le']
   # display output
   self.ui.put('%s ' % msg)
   self.progress = util.progress(ui, 8, size)

def row_search(OPTS, m, line_tups):
    """Writes the scan results to a pickle file.

    The pickled object is a  dictionary with cne names as keys and list as value.
    Each list contains tuples of (coord, index) where coord is a coord dict
    and index is int index starting from 0.
    """
    rows = {}
    for i, l in enumerate(line_tups):
        name, a, b, c, = l[0], l[OPTS.a-1], l[OPTS.b-1], parse_coords(l[OPTS.c-1])
        m.fit([a])
        hits = m.scan([b], n=None, reverse_complement=True, sort=False)[0]
        scores = [score for index, score in hits]
        rows[name] = scores
        progress(50, (float(i)+1)/len(line_tups)*100, pre="Processing genes")
    pkl_filename = OPTS.model + '.pkl'
    sys.stdout.write("Writing pickle file %s. Do not exit!\n" % pkl_filename)
    pkl = open(OPTS.model + '.pkl', 'wb')
    pickle.dump(rows, pkl, pickle.HIGHEST_PROTOCOL)

def separate(lines, p, train_out, test_out):
    dataset = list(mecab.load(lines))
    random.shuffle(dataset)
    for i, sentence in enumerate(dataset, 1):
        if random.random() < p:
            pickle.dump(sentence, train_out)
        else:
            pickle.dump(sentence, test_out)
        if i % 100 == 0:
            print(util.progress('write', i / len(dataset), 100), end='')
    print()

def base(d, player):
    code, tag = d.menu("Vous entrez dans le chateau il est tres grand.",
                       choices=[("(1)", "Parler aux gardes"),
                                ("(2)", "Aller à la salle du trone"),
                                ("(3)", "Revenir a la ville"),
                                ("(4)", "Afficher mon inventaire")],
                       ok_label="Ok, je veux faire ça",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            d.msgbox(
                """Les gardes vous interpellent sans vous laiser le temps de parler  "Vous ètes ici pour teter d'arretez le Sorcier? aller à la salle du trone""")
            code, tag = d.menu("Que dire ?",
                               choices=[
                                   ("(1)", "Le sorcier ?"),
                                   ("(2)", "Oui c'est exactement cela!")
                               ],
                               ok_label="Dire ça",
                               cancel_label="mettre fin à la conversation")
            if code == d.OK:
                if tag == "(1)":
                    d.msgbox("Oui le Sorcier qui est la cause de tous les problème. D'ou sortez vous? bon sang!")
                elif tag == "(2)":
                    d.msgbox("Encore un prétentieux qui va mourir.")
                else:
                    d.msgbox("Vous dites au revoir aux gardes")
                    return True
            else:
                return "pref"
        elif tag == "(2)":
            progress(d, 15, "Vous allez dans la salle du trone", player)
            database.players.changePref(player, "location", "salleDuTrone")
        elif tag == "(3)":
            database.players.changePref(player, "location", "centreVille")
            return True

        elif tag == "(4)":
            showInventory(d, player)
            return True
    else:
        return "pref"

def base(d, player):
    code, tag = d.menu("Vous etes arrivé a la ville de NullePart. La ville est grande. Il y a quelques passants. ",
                       choices=[("(1)", "Aller au centre ville"),
                                ("(2)", "Prendre le bus jusqu'à la maison (2x or)"),
                                ("(3)", "Rentrer vers la pleine"),
                                ("(4)", "Afficher mon inventaire")
                                ],
                       ok_label="Ok, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            progress(d, 15, "Vous marchez jusqu'au centre ville.", player)
            database.players.changePref(player, "location", "centreVille")
            return True
        elif tag == "(2)":
            if database.inventory.addToInventory(player, "or", -2):
                progress(d, 10, "Le bus vous ramene chez vous.", player)
                database.players.changePref(player, "location", "maison")
                return True
            else:
                d.msgbox("Impossible. Vous n'avez pas asser d'argent !")
                return True

        elif tag == "(3)":
            progress(d, 60, "Vous rebroussez chemain vers la plaine", player)
            database.players.changePref(player, "location", "terreDeChaisPasOu")
            return True

        elif tag == "(4)":
            showInventory(d, player)
            return True
    else:
        return "pref"

def base(d, player):
    code, tag = d.menu("Vous ètes dans les montagnes, il y a un chateau et une caverne.",
                       choices=[("(1)", "Aller dans le chateau"),
                                ("(2)", "Aller dans la caverne."),
                                ("(3)", "Retourner dans la ville."),
                                ("(4)", "Afficher mon inventaire.")],
                       ok_label="Ok je veux faire ça",
                       cancel_label="Préférance/Quitter")
    if code == d.OK:
        if tag == "(1)":
            progress(d, 30, "Vous allez dans le chateau.", player)
            database.players.changePref(player, "location", "chateauMontagne")
            return True
        elif tag == "(2)":
            progress(d, 20, "Vous rentrez dans la grotte, mais il s'agit d'un repère de brigand", player)
            database.players.changePref(player, "location", "caverne")
            return True
        elif tag == "(3)":
            progress(d, 30, "Vous retournez dans la ville.", player)
            database.players.changePref(player, "location", "quartierSud")
            return True
        elif tag == "(4)":
            showInventory(d, player)
            return True
        else:
            return "pref"

def base(d, player):
    code, tag = d.menu("Vous êtes dans le petit bois. Que voulez-vous faire ?",
                       choices=[("(1)", "Fouiller la terre"),
                                ("(2)", "Continuer sur ce sentier"),
                                ("(3)", "Rentrer à la maison"),
                                ("(4)", "Afficher mon inventaire")],
                       ok_label="Ok, je veux faire ca",
                       cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            d.msgbox("Vous creusez dans ce bois.")
            progress(d, 20, "Vous creusez la terre...", player)
            database.inventory.addToInventory(player, "brindilles", 20)
            database.inventory.addToInventory(player, "terre", 5)
            d.msgbox("Vous trouvez 5 terre et 2 brindilles.")
            return True
        elif tag == "(2)":
            progress(d, 25, "Vous continuez sur le sentier... Il semble en bien plus mauvais état !", player)
            database.players.changePref(player, "location", "terreDeChaisPasOu")
            return True
        elif tag == "(3)":
            progress(d, 10, "Vous rentrez à la maison...", player)
            database.players.changePref(player, "location", "maison")
            return True
        elif tag == "(4)":
            showInventory(d, player)
            return True
    else:
        return "pref"

def base(d, player):
    code, tag = d.menu(
        "Vous etes dans une grande plaine. Un panneau indique : \"terre de chais pas où\". Le reste du panneau est effacé. Il semble y avoir une boutique un peu plus loin.",
        choices=[("(1)", "Aller dans le magasin"),
                 ("(2)", "Continuer sur le santier"),
                 ("(3)", "Rentrer à la fôret"),
                 ("(4)", "Afficher mon inventaire")
                 ],
        ok_label="Ok, je veux faire ca",
        cancel_label="Préférances/Quitter")
    if code == d.OK:
        if tag == "(1)":
            progress(d, 3, "Vous allez vers la boutique.", player)
            database.players.changePref(player, "location", "magasinTDCPO")
            return True
        elif tag == "(2)":
            if database.inventory.getItemNumber(player, "lunettes") != 0:
                progress(d, 60, "Vous continuez sur le sentier. Il est quasiment invisible.", player)
                database.players.changePref(player, "location", "villeDeNullepart")
                return True
            else:
                d.msgbox("Impossible. Le chemin est presque indiscernable à partir d'ici !")
                return True

        elif tag == "(3)":
            progress(d, 25, "Vous rebroussez chemain vers la forèt", player)
            database.players.changePref(player, "location", "bois")
            return True

        elif tag == "(4)":
            showInventory(d, player)
            return True
    else:
        return "pref"

def computeFBANKDeltaDelta(sswi,NFilt=40,NDelta=2):
    nframes = speakersent.countFrames(sswi)
    NFilt=NFilt+1 # Energy values count as one extra
    features = np.zeros(shape=(nframes,NFilt*3))
    util.startprogress("FBANK Features")
    frameCnt=0
    for k,v in sswi.iteritems(): # k: speakerId, v: dict with sentenceId
        speaker_=k
        for k2,v2 in v.iteritems(): # k2: sentenceId, v: dict with frameId -> entry
            sent_=k2
            r,sig=getWavFile(speaker_,sent_)
            fbank_frames,energy=fbank(sig,r,winlen=winlen,winstep=winstep,nfilt=NFilt-1)
            fbank_frames=np.log(np.append(np.reshape(energy,(energy.shape[0],1)),fbank_frames,axis=1))
            delta_1 = computeDelta(fbank_frames,N=NDelta)
            delta_2 = computeDelta(delta_1,N=NDelta)
            util.progress(float(frameCnt)/nframes*100.0)
            for i in range(len(v2)):
                frameCnt+=1
                features[v2[i+1],:NFilt]=fbank_frames[i,:]                
                features[v2[i+1],NFilt:2*NFilt]=delta_1[i,:]                
                features[v2[i+1],2*NFilt:]=delta_2[i,:]
    util.endprogress()
    return features