def register(username, password):
	"""Registra el usuario y clave, devuelve:
		0 si se registro exitosamente
		1 si el usuario ya existe
		2 si hubo otro problema
	"""
	username = utils.clean(username)
	password = utils.clean(password)

	# vemos si existe (medio feo, pero por ahora funciona, dependemos de
	# que get_personal tira una excepcion si el usuario no existe)
	p = None
	try:
		p = get_personal(username)
	except:
		pass
	if p != None:
		return 1

	p = Personal()
	p.username = username
	p.password = password

	try:
		p.save()
	except:
		return 2
	return 0

def get_data():
    path = '/Users/zyzdiana/Dropbox/vNav_Test_Data/Apr_17_test_data/'
    dict_10mm = {}
    dict_6_4mm = {}
    dict_8mm = {}
    for root, dirs, files in os.walk(path):
        if len(dirs)==0:
            if('10mm' in root):
                dict_10mm[root] = clean(files)
            if('6_4mm' in root):
                dict_6_4mm[root] = clean(files)
            if('8mm' in root):
                dict_8mm[root] = clean(files)

    list_10mm = []
    for item in dict_10mm.iteritems():
        list_10mm.append(os.path.join(item[0],item[1][0]))
    list_10mm.sort()
    vols_10mm = get_volume(list_10mm, 26)
    list_6_4mm = []
    for item in dict_6_4mm.iteritems():
        list_6_4mm.append(os.path.join(item[0],item[1][0]))
    list_6_4mm.sort()
    vols_6_4mm = get_volume(list_6_4mm, 40)
    list_8mm = []
    for item in dict_8mm.iteritems():
        list_8mm.append(os.path.join(item[0],item[1][0]))
    list_8mm.sort()
    vols_8mm = get_volume(list_8mm, 32)
    return vols_6_4mm, vols_8mm, vols_10mm

def get_data_all():
    path = '/Users/zyzdiana/Dropbox/vNav_Test_Data/Apr_17_test_data/'
    dict_10mm = {}
    dict_6_4mm = {}
    dict_8mm = {}
    for root, dirs, files in os.walk(path):
        if len(dirs)==0:
            if('10mm' in root):
                dict_10mm[root] = clean(files)
            if('6_4mm' in root):
                dict_6_4mm[root] = clean(files)
            if('8mm' in root):
                dict_8mm[root] = clean(files)
    keys_10 = sorted(dict_10mm.keys())
    keys_8 = sorted(dict_8mm.keys())
    keys_6_4 = sorted(dict_6_4mm.keys())
    all_10mm = {}
    all_8mm = {}
    all_6_4mm = {}
    for i in xrange(5):
        all_10mm[idx_to_key(i, keys_10)] = []
        all_8mm[idx_to_key(i, keys_8)] = []
        all_6_4mm[idx_to_key(i, keys_6_4)] = []
        for j in xrange(5):
            # 10mm
            path = os.path.join(idx_to_key(i, keys_10),dict_10mm[idx_to_key(i, keys_10)][j])
            all_10mm[idx_to_key(i, keys_10)].append(get_volume_1(path, 26))
            # 8mm
            path = os.path.join(idx_to_key(i, keys_8),dict_8mm[idx_to_key(i, keys_8)][j])
            all_8mm[idx_to_key(i, keys_8)].append(get_volume_1(path, 32))
            # 6.4mm
            path = os.path.join(idx_to_key(i, keys_6_4),dict_6_4mm[idx_to_key(i, keys_6_4)][j])
            all_6_4mm[idx_to_key(i, keys_6_4)].append(get_volume_1(path, 40))
    return all_10mm, all_8mm, all_6_4mm

def main(_):

    if FLAGS.train:
        if FLAGS.clean:
            clean(FLAGS)
        train()
    else:
        evaluate_line()

def install():
    utils.clean()
    peg.install()
    fcgi.install()
    json_glib.install()
    discount.install()
    balde.install()
    bluster.install()
    utils.clean()

def register(username, password):
	"""Registra el usuario y clave, devuelve:
		0 si se registro exitosamente
		1 si el usuario ya existe
		2 si hubo otro problema
	"""
	# TODO: si alguien molesta con esto, hay que armar un mecanismo para
	# evitar DoS (tampoco es muy complicado).

	username = utils.clean(username)
	password = utils.clean(password)
	return personal.register(username, password)

def listar_radios(name,url):
    link= clean(abrir_url(url))
    radios=re.compile('<td><a href="/portalradio/conteudos/ficha/.+?radio_id=(.+?)">(.+?)</a></td><td>(.+?)</td>.+?<td align="center">').findall(link)
    for idradio,nomeradio,concelho in radios:
        addDir('[B]'+nomeradio+'[/B] ('+concelho+')',RadiosURL + 'Sintonizador/?radio_id=' + idradio + '&scope=0',21,'http://www.radio.com.pt/APR.ROLI.WEB/Images/Logos/'+ idradio +'.gif',len(radios),'',False)
    xbmc.executebuiltin("Container.SetViewMode(501)")
    paginasradios(url,link)

    def eligibility(self):
        try:
            table = utils.Table(self.soup.select("table[summary~=Land]")[0])
        except IndexError:
            return None

        return utils.clean(table["Eligibility"].text.strip())

	def load_words(self, folderpath):
		filenames = glob.glob(folderpath)
		for f in filenames:
			with open(f, 'r') as infile:
				text = infile.read()
				text = utils.clean(text)
				self.words.append([text])

	def post(self):
		db=self.application.database
		content = self.request.arguments.get("content", [""])[0]
		parent = self.request.arguments.get("parent", [None])[0]
		super_parent = self.request.arguments.get("super_parent", [None])[0]

		content = clean(content)
		
		new_comment = {
			"content" : content,
			"time" : datetime.utcnow(),
			"author" : self.get_current_user(),
			"plusvote": list(),
			"minusvote": list()
		}

		if parent != None:
			new_comment["parent"] = parent
		if super_parent != None:
			new_comment["super_parent"] = super_parent
		new_id = db.comments.insert(new_comment)
		print new_id
		print parent
		print db.comments.update({"_id": ObjectId(parent)}, {"$push": {"children": str(new_id)}})
		self.redirect("/")

    def __init__(self, schema, output_dir=None):
        ''' Bind array of cleaned schema file lines to validator object. ''' 

        self.schema = utils.clean(schema)
        self.output_dir = output_dir
        self.indent_size = self._find_first_indent()['indent_size']
        self.error = {'msg': None}

def rate(classifier,filename,medi,mad,medi_ld,mad_ld):
	#For now, just assuming the text is csv
	results = classifier
	with open(filename,'rU') as f:
		reader = csv.reader(f,delimiter=',')
		data = [(get_features(tech.clean(row[2]),medi,mad,medi_ld,mad_ld),row[0]) for row in reader]
	print nltk.classify.accuracy(classifier,data)

 def new(self):
     self.name = self.parse('company.name')
     self.suffix = self.fetch('company.suffix')
     self.website = "http://www.%s.%s" % (
         clean(self.name),
         self.fetch('internet.domain_suffix')
         )

 def process_text(self):
     text = utils.clean(self.get_tweet_text())
     self.set_tweet_text(text)
     self.set_tweet_source(utils.parse_alink(self.get_tweet_source()))
     if self.translation:
         self.detect_language_or_translate()
     self.filter_text()

def listasextras():
    iptvurl='http://01.gen.tr/HasBahCa_IPTV/'
    link= clean(abrir_url(iptvurl))
    streams=re.compile('<a class="autoindex_a" href="./(.+?)">.+?<td class="autoindex_td_right">.+?</td.+?td class="autoindex_td_right">(.+?)</td>').findall(link)
    for nomepasta,act in streams:
        if re.search('.m3u',nomepasta):
            titulo=nomepasta.replace('.m3u','').replace('_',' ').title()
            addDir("[B]%s[/B] (act.%s)" % (titulo,act[2:-2]),iptvurl + nomepasta,5,tvporpath + art + 'listas-ver2.png',1,'',True)

    def findName(self, code):

        s = code.find("def")+len("def")
        e = code.find("(")

        name = code[s:e]

        return clean(name)

def radiosobterurlstream(name,url):
    #GA("None","Radio - " + name)
    mensagemprogresso.create('TV Portuguesa','A carregar...')
    mensagemprogresso.update(0)
    if re.search('www.radios.pt',url):
        link=abrir_url(url)
        try:
            endereco=re.compile('<param name="url" value="(.+?)"').findall(link)[0]
        except:
            xbmc.executebuiltin("XBMC.Notification(Fightnight Music,Não é possível ouvir esta rádio.,'500000',)")
            return
        idradio=url.replace('http://www.radios.pt/portalradio/Sintonizador/?radio_id=','').replace('&scope=0','')
        thumbnail='http://www.radio.com.pt/APR.ROLI.WEB/Images/Logos/'+ idradio +'.gif'
    else:
        urlfinal='http://www.radioonline.com.pt/ajax/player.php?clear_s_name=' + url
        link= clean(abrir_url(urlfinal))
        try: player=re.compile('soundManager.createSound\({(.+?)autoLoad').findall(link)[0]
        except: player=False
        try:
            endereco=re.compile('url: "(.+?)"').findall(player)[0].replace(';','')
            if re.search('serverURL',player):
                rtmp=re.compile('serverURL: "(.+?)"').findall(player)[0]
                #rtmp=rtmp.replace('rtmp://195.23.102.206','rtmp://195.23.102.209') #tempfix
                rtmp=rtmp.replace(':1936','') #tempfix
                endereco=rtmp + ' playPath=' + endereco

        except:endereco=False
        if not endereco:
            try:endereco=re.compile('<param name="URL" value="(.+?)"').findall(link)[0]
            except:
                try: endereco=re.compile('<object data="(.+?)"').findall(link)[0]
                except: endereco=False

        if not endereco:
            xbmc.executebuiltin("XBMC.Notification(TV Portuguesa,Não é possível ouvir esta rádio.,'500000',)")
            mensagemprogresso.close()
            return

        try:thumbnail=re.compile('<img id="station-logo-player" src="(.+?)"').findall(link)[0]
        except: thumbnail=''
        if re.search('.asx',endereco):
            nomeasx='stream.asx'
            path = xbmc.translatePath(os.path.join(pastaperfil))
            lib=os.path.join(path, nomeasx)
            downloader(endereco,lib)
            texto= openfile(nomeasx)
            endereco = xbmc.PlayList(1)
            endereco.clear()
            streams=re.compile('<ref.+?"(.+?)"/>').findall(texto)
            for musica in streams:
                listitem = xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=thumbnail)
                listitem.setInfo("music", {"Title":name})
                endereco.add(musica,listitem)
        else: pass
    mensagemprogresso.close()
    listitem = xbmcgui.ListItem(name, iconImage="DefaultVideo.png", thumbnailImage=thumbnail)
    listitem.setInfo("music", {"Title":name})
    xbmc.Player().play(endereco,listitem)

def radioslocais():
    link= clean(abrir_url(RadiosURL))
    #addDir('Pesquisar (exclui nacionais)',RadiosURL + '?distrito=0&concelho=0&tipo=0&text=',16,'',1,'',True)
    distritos=re.compile('id="DirectorioPesquisa1_ddlDistritos">(.+?)</select>').findall(link)[0]
    distritos=distritos.replace('<option value="0"></option>','<option value="0">Todos as rádios locais</option>')
    lista=re.compile('<option value="(.+?)">(.+?)</option>').findall(distritos)
    for iddistrito,nomedistrito in lista:
        addDir(nomedistrito,RadiosURL + '?distrito=' + iddistrito + '&concelho=0&tipo=0',24,'',len(lista),'',True)
    xbmc.executebuiltin("Container.SetViewMode(501)")

def main(args):
    content_generator = load_file(args.transcript, encoding=args.encoding)
    rules = load_rules(args.rules, encoding=args.encoding)

    mapped = do_mapping(content_generator, rules)
    cleaned = clean(mapped)
    formatted = mlf_format_data(cleaned)

    save_file(args.output, formatted, encoding=args.encoding)

def manage_addPingback(self, sourceTitle, sourceURI, sourceExcerpt):
    """ Add a pingback """
    from utils import isPingbackSpam

    if isPingbackSpam(sourceTitle, sourceURI, sourceExcerpt,
                      self.blogurl(), self.REQUEST):
        try:
            return self.REQUEST.RESPONSE.redirect('http://www.google.com')
        except:
            return 0

    id = self.createReferenceId()
    newTitle = clean(sourceTitle)
    newURI = clean(sourceURI)
    newExcerpt = clean(sourceExcerpt)
    pingback = Reference(id, newTitle, newURI, newExcerpt, self.getId())
    self._setObject(id, pingback)
    return 1