def __init__(self):
self.ips = []
print "Iniciando busca remota no servidor"
self.resultado = ""
self.aux = Auxiliares()
self.host = ""
self.port = 42000
self.termo = ""
def __init__(self, assunto="network"):
self.lex = LeXML(assunto)
self.termos_pontos={}
self.aux = Auxiliares()
self.pontuacao=0
self.numero_palavras=0
self.palavras_encontradas=0
self.percentual_palavras_texto=0
self.categoria_busca=""
class ProcuraMaquinas(BaseBusca):
def __init__(self):
print "Procura Maquinas"
self.aux = Auxiliares()
self.resultado = ""
self.lista_maquinas = []
def desconectar(self, sock):
print "Conexão terminada!"
sock.close()
def conectar(self, host, port):
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
mySocket.connect((host, port))
print "Connectado ao servidor"
except:
print "Nao foi possível conectar: ", host
return -1
return mySocket
# montar um network scanner a partir da mascara de rede
def scanMask(self, tripla, inicial, final):
for ip1 in range(inicial, final):
self.aux.printDebug("Numero IP: ", tripla + "." + str(ip1))
self.scanHost(tripla + "." + str(ip1), PORT)
return self.lista_maquinas
def scanNet(self, hosts):
for host in hosts:
self.scanHost(host, PORT)
return self.lista_maquinas
def scanHost(self, host, port):
res = self.conectar(host, port)
if res != -1:
print "Maquina ", host, ":", PORT, " pronta para a busca!"
self.lista_maquinas.append(host)
self.desconectar(res)
return 1
else:
return -1
def __init__(self):
self.ips = []
print "Iniciando busca remota no servidor"
self.resultado = ""
self.aux = Auxiliares()
self.host = ""
self.port = 42000
self.termo = ""
class ProcuraMaquinas(BaseBusca):
def __init__(self):
print "Procura Maquinas"
self.aux = Auxiliares()
self.resultado = ""
self.lista_maquinas = []
def desconectar(self, sock):
print "Conexão terminada!"
sock.close()
def conectar(self, host, port):
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
mySocket.connect((host, port))
print "Connectado ao servidor"
except:
print "Nao foi possível conectar: ", host
return -1
return mySocket
# montar um network scanner a partir da mascara de rede
def scanMask(self, tripla, inicial, final):
for ip1 in range(inicial, final):
self.aux.printDebug("Numero IP: ", tripla + "." + str(ip1))
self.scanHost(tripla + "." + str(ip1), PORT)
return self.lista_maquinas
def scanNet(self, hosts):
for host in hosts:
self.scanHost(host, PORT)
return self.lista_maquinas
def scanHost(self, host, port):
res = self.conectar(host, port)
if res != -1:
print "Maquina ", host, ":", PORT, " pronta para a busca!"
self.lista_maquinas.append(host)
self.desconectar(res)
return 1
else:
return -1
def __init__(self, assunto="network"):
self.lex = LeXML(assunto)
self.termos_pontos = {}
self.aux = Auxiliares()
self.pontuacao = 0
self.numero_palavras = 0
self.palavras_encontradas = 0
self.percentual_palavras_texto = 0
self.categoria_busca = ""
class Procura(BaseBusca):
def __init__(self, assunto="network"):
self.lex = LeXML(assunto)
self.termos_pontos={}
self.aux = Auxiliares()
self.pontuacao=0
self.numero_palavras=0
self.palavras_encontradas=0
self.percentual_palavras_texto=0
self.categoria_busca=""
# Logica "Difusa"
#-----------------------
# media >= 70% - altamente relevante
# 30% < media < 70% - relevante
# media for <= 30% - inrelevante
def fuzzinator(self):
media=self.obtemPontosPorPalavra()/self.obtemPontosPorPalavraCategoria()
if media >= 0.70:return "alta"
if media <= 0.30:return "baixa"
return "media"
def obtemNumeroPalavrasEncontradas(self):
return self.palavras_encontradas
def obtemNumeroPalavras(self):
return self.numero_palavras
def obtemPontuacao(self):
#re read the XML file with the new information
self.lex = LeXML()
return self.pontuacao
def obtemPontosPorPalavra(self):
return float(self.obtemPontuacao())/float(self.obtemNumeroPalavras())
def obtemPontosCategoria (self):
return self.lex.obtemPontosCategoria()
def obtemPalavrasCategoria (self):
return self.lex.obtemPalavrasCategoria()
def obtemPontosPorPalavraCategoria(self):
return float(self.obtemPontosCategoria ())/float(self.obtemPalavrasCategoria ())
def obtemPercentualPalavrasCategoria(self):
return self.percentual_palavras_texto
def obtemCategoria(self):
return self.categoria_busca
def procurarPontuar(self, categoria, texto=""):
self.pontuacao=0
ocorrencias=0
if not texto:
texto=self.obtemConteudo()
self.numero_palavras=len(texto.split(' '))
self.percentual_palavras_texto=self.lex.obtemPercentualCategoria(categoria)
self.categoria_busca=categoria
# levantar pesos e pontos
for palavras in self.lex.getPalavrasCategoria(categoria):
let = LeTesauro()
pot = PontuaTexto(palavras.get('valor').lower(), texto.lower())
ocorrencias=pot.procuraPalavraTexto(palavras.get('valor').lower(), texto.lower())
if ocorrencias != 0:
self.aux.printDebug("["+str(palavras.get('valor'))+ "]="+ str(palavras.get('pontos'))+ "*"+str(ocorrencias*110))
self.pontuacao += int(palavras.get('pontos'))*(ocorrencias*110) #se um sinonimo vale 100 a palavra q leva a ele tbm merece o merito
self.palavras_encontradas+=ocorrencias
termos_pontos = let.buscaTermo(palavras.get('valor'), palavras.get('pontos'))
#print termos_pontos
# procurar para cada palavra
if termos_pontos:
# self.aux.printDebug(termos_pontos)
for termo in termos_pontos:
self.aux.printDebug(termo)
pote = PontuaTexto(termo.lower(), texto.lower())
ocorrencias=pote.procuraPalavraTexto(termo.lower(), texto.lower())
if ocorrencias != 0:
self.aux.printDebug("\t["+ termo+ "]="+str( termos_pontos[termo] )+ "*"+str( ocorrencias))
self.pontuacao += termos_pontos[termo]*ocorrencias
self.palavras_encontradas+=ocorrencias
# defineConteudo:
# @meio: como os dados devem ser buscados
# @dados: e uma variavel que poder ter tipos diferentes de acordo com a necessidade, essa necessidade
# indica: meios para se obter a informacao a ser procurada
def defineConteudo(self, meio, dados):
print "-"*30
if meio == 1:#"buscaremota":
print "buscaremota"
cli=BuscaRemotaCliente()
ip=raw_input("Digite o ip: ")
termo_procura=raw_input("Buscar: ")
cli.defineHost(ip)
cli.busca( ip , 42000, termo_procura)
SU.printr(cli.obtemResultado())
elif meio == 2:# "rede":
print "rede"
tripla = raw_input("Digite a tripla: ")
inicio = raw_input("Digite o num inicial: ")
final = raw_input("Digite o num final: ")
termo_procura= raw_input("Digite o conteudo a procurar nos computadores encontrados: ")
if not tripla: tripla="127.0.0"
if not inicio: inicio=1
if not final: final=255
cli=BuscaRemotaCliente()
a=1
pm = ProcuraMaquinas()
for maquina in pm.scanMask(tripla, int(inicio), int(final)):
a=0
cli.busca( maquina , 42000, termo_procura)
SU.printr(cli.obtemResultado())
if a==1: print "Sem maquinas para conectar"
#lista_maquinas = pm.scanMask(tripla, int(inicio), int(final))
#
#maquina=lista_maquinas.pop(0)
#cli.defineHost(maquina)
#cli.defineListaMaquinas(lista_maquinas)
#cli.busca( maquina , 42000, termo_procura)
#SU.printr(cli.obtemResultado())
#aqui entraria um codigo para aguardar o agente retornar com os dados das buscas pela rede
elif meio == 3:# "internet":
print "internet"
meuRobo = Robo()
site = raw_input("Digite o endereco do site: ")
if site: meuRobo.defineSite(site)
self.defineConteudo(meuRobo.obtemConteudo())
elif meio == 4:# "local": #arquivos locais
print "local"
procura = BuscaArquivo()
procura.defineNomeArquivo("*mp3*")
procura.defineDiretorio("/home/daniel/media/mp3")
resultado=procura.buscaArquivo()
SU.printr(resultado)
#procura.buscaConteudo(".", "python")
elif meio == 5:#"texto":
print "texto"
pr = Procura()
pr.procurarPontuar("network", dados.lower())
print "Categoria: ", pr.obtemCategoria().upper()
print "\tPontos: \t[" , pr.obtemPontuacao() , "]"
print "\tRelevancia: \t[", pr.fuzzinator().upper() , "]"
print "\tPontos por palavra: \t[" , int(pr.obtemPontosPorPalavra()), "]"
#print pr.obtemPalavrasCategoria()
#print pr.obtemNumeroPalavras()
##print pr.obtemPercentualPalavrasCategoria()
#
#print pr.obtemPercentualPalavrasCategoria(), "",pr.obtemPontosPorPalavra(), ""
#print pr.obtemPontosPorPalavraCategoria() , "", pr.obtemPontosCategoria()
else: print "Opcao Invalida"
print "Fim."
class BuscaRemotaCliente:
def __init__(self):
self.ips = []
print "Iniciando busca remota no servidor"
self.resultado = ""
self.aux = Auxiliares()
self.host = ""
self.port = 42000
self.termo = ""
def defineHost(self, host):
self.host = host
def definePort(self, port):
self.port = port
def obtemResultado(self):
return self.resultado
def busca(self, host, port, termo):
sock = self.conectar(host, port)
if sock != -1:
self.buscaRemota(sock, termo)
self.desconectar(sock)
def conectar(self, host, port):
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
mySocket.connect((host, port))
print "Connectado ao servidor"
except:
print "ERRO ao conectar"
return -1
return mySocket
def desconectar(self, sock):
print "Conexao terminada!"
sock.close()
def defineListaMaquinas(self, lista_maquinas):
self.lista_maquinas = lista_maquinas
def obtemListaMaquinas(self):
return self.lista_maquinas
def buscaRemota(self, mySocket, termo):
serverMessage = mySocket.recv(1024)
if not serverMessage:
return
procura = ba.BuscaArquivo()
procura.defineNomeArquivo(termo)
if self.lista_maquinas:
procura.defineListaMaquinas(self.obtemListaMaquinas())
procura.defineDiretorio("/home/daniel/media/mp3")
mySocket.send(pickle.dumps(procura))
self.aux.printDebug("Agente enviado")
serverMessage = " " # mySocket.recv( 1024 )
cli_resultado = ""
while serverMessage != "\n":
serverMessage = mySocket.recv(1024)
if serverMessage != "\n":
cli_resultado += serverMessage
# print "recebendo["+serverMessage+"]"
# print clientMessage ,"", serverMessage
self.aux.printDebug("Agente recebido de volta")
ag_procura = pickle.loads(cli_resultado)
self.resultado = ag_procura.obtemResultado()
def __init__(self):
print "Procura Maquinas"
self.aux = Auxiliares()
self.resultado = ""
self.lista_maquinas = []
def __init__(self):
print "Procura Maquinas"
self.aux = Auxiliares()
self.resultado = ""
self.lista_maquinas = []
class BuscaRemotaCliente:
def __init__(self):
self.ips = []
print "Iniciando busca remota no servidor"
self.resultado = ""
self.aux = Auxiliares()
self.host = ""
self.port = 42000
self.termo = ""
def defineHost(self, host):
self.host = host
def definePort(self, port):
self.port = port
def obtemResultado(self):
return self.resultado
def busca(self, host, port, termo):
sock = self.conectar(host, port)
if sock != -1:
self.buscaRemota(sock, termo)
self.desconectar(sock)
def conectar(self, host, port):
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
mySocket.connect((host, port))
print "Connectado ao servidor"
except:
print "ERRO ao conectar"
return -1
return mySocket
def desconectar(self, sock):
print "Conexao terminada!"
sock.close()
def defineListaMaquinas(self, lista_maquinas):
self.lista_maquinas = lista_maquinas
def obtemListaMaquinas(self):
return self.lista_maquinas
def buscaRemota(self, mySocket, termo):
serverMessage = mySocket.recv(1024)
if not serverMessage:
return
procura = ba.BuscaArquivo()
procura.defineNomeArquivo(termo)
if self.lista_maquinas:
procura.defineListaMaquinas(self.obtemListaMaquinas())
procura.defineDiretorio("/home/daniel/media/mp3")
mySocket.send(pickle.dumps(procura))
self.aux.printDebug("Agente enviado")
serverMessage = " " # mySocket.recv( 1024 )
cli_resultado = ""
while serverMessage != "\n":
serverMessage = mySocket.recv(1024)
if serverMessage != "\n":
cli_resultado += serverMessage
# print "recebendo["+serverMessage+"]"
# print clientMessage ,"", serverMessage
self.aux.printDebug("Agente recebido de volta")
ag_procura = pickle.loads(cli_resultado)
self.resultado = ag_procura.obtemResultado()
class Procura(BaseBusca):
def __init__(self, assunto="network"):
self.lex = LeXML(assunto)
self.termos_pontos = {}
self.aux = Auxiliares()
self.pontuacao = 0
self.numero_palavras = 0
self.palavras_encontradas = 0
self.percentual_palavras_texto = 0
self.categoria_busca = ""
# Logica "Difusa"
# -----------------------
# media >= 70% - altamente relevante
# 30% < media < 70% - relevante
# media for <= 30% - inrelevante
def fuzzinator(self):
media = self.obtemPontosPorPalavra() / self.obtemPontosPorPalavraCategoria()
if media >= 0.70:
return "alta"
if media <= 0.30:
return "baixa"
return "media"
def obtemNumeroPalavrasEncontradas(self):
return self.palavras_encontradas
def obtemNumeroPalavras(self):
return self.numero_palavras
def obtemPontuacao(self):
# re read the XML file with the new information
self.lex = LeXML()
return self.pontuacao
def obtemPontosPorPalavra(self):
return float(self.obtemPontuacao()) / float(self.obtemNumeroPalavras())
def obtemPontosCategoria(self):
return self.lex.obtemPontosCategoria()
def obtemPalavrasCategoria(self):
return self.lex.obtemPalavrasCategoria()
def obtemPontosPorPalavraCategoria(self):
return float(self.obtemPontosCategoria()) / float(self.obtemPalavrasCategoria())
def obtemPercentualPalavrasCategoria(self):
return self.percentual_palavras_texto
def obtemCategoria(self):
return self.categoria_busca
def procurarPontuar(self, categoria, texto=""):
self.pontuacao = 0
ocorrencias = 0
if not texto:
texto = self.obtemConteudo()
self.numero_palavras = len(texto.split(" "))
self.percentual_palavras_texto = self.lex.obtemPercentualCategoria(categoria)
self.categoria_busca = categoria
# levantar pesos e pontos
for palavras in self.lex.getPalavrasCategoria(categoria):
let = LeTesauro()
pot = PontuaTexto(palavras.get("valor").lower(), texto.lower())
ocorrencias = pot.procuraPalavraTexto(palavras.get("valor").lower(), texto.lower())
if ocorrencias != 0:
self.aux.printDebug(
"[" + str(palavras.get("valor")) + "]=" + str(palavras.get("pontos")) + "*" + str(ocorrencias * 110)
)
self.pontuacao += int(palavras.get("pontos")) * (
ocorrencias * 110
) # se um sinonimo vale 100 a palavra q leva a ele tbm merece o merito
self.palavras_encontradas += ocorrencias
termos_pontos = let.buscaTermo(palavras.get("valor"), palavras.get("pontos"))
# print termos_pontos
# procurar para cada palavra
if termos_pontos:
# self.aux.printDebug(termos_pontos)
for termo in termos_pontos:
self.aux.printDebug(termo)
pote = PontuaTexto(termo.lower(), texto.lower())
ocorrencias = pote.procuraPalavraTexto(termo.lower(), texto.lower())
if ocorrencias != 0:
self.aux.printDebug("\t[" + termo + "]=" + str(termos_pontos[termo]) + "*" + str(ocorrencias))
self.pontuacao += termos_pontos[termo] * ocorrencias
self.palavras_encontradas += ocorrencias
# defineConteudo:
# @meio: como os dados devem ser buscados
# @dados: e uma variavel que poder ter tipos diferentes de acordo com a necessidade, essa necessidade
# indica: meios para se obter a informacao a ser procurada
def defineConteudo(self, meio, dados):
print "-" * 30
if meio == 1: # "buscaremota":
print "buscaremota"
cli = BuscaRemotaCliente()
ip = raw_input("Digite o ip: ")
termo_procura = raw_input("Buscar: ")
cli.defineHost(ip)
cli.busca(ip, 42000, termo_procura)
SU.printr(cli.obtemResultado())
elif meio == 2: # "rede":
print "rede"
tripla = raw_input("Digite a tripla: ")
inicio = raw_input("Digite o num inicial: ")
final = raw_input("Digite o num final: ")
termo_procura = raw_input("Digite o conteudo a procurar nos computadores encontrados: ")
if not tripla:
tripla = "127.0.0"
if not inicio:
inicio = 1
if not final:
final = 255
cli = BuscaRemotaCliente()
a = 1
pm = ProcuraMaquinas()
for maquina in pm.scanMask(tripla, int(inicio), int(final)):
a = 0
cli.busca(maquina, 42000, termo_procura)
SU.printr(cli.obtemResultado())
if a == 1:
print "Sem maquinas para conectar"
# lista_maquinas = pm.scanMask(tripla, int(inicio), int(final))
#
# maquina=lista_maquinas.pop(0)
# cli.defineHost(maquina)
# cli.defineListaMaquinas(lista_maquinas)
# cli.busca( maquina , 42000, termo_procura)
# SU.printr(cli.obtemResultado())
# aqui entraria um codigo para aguardar o agente retornar com os dados das buscas pela rede
elif meio == 3: # "internet":
print "internet"
meuRobo = Robo()
site = raw_input("Digite o endereco do site: ")
if site:
meuRobo.defineSite(site)
self.defineConteudo(meuRobo.obtemConteudo())
elif meio == 4: # "local": #arquivos locais
print "local"
procura = BuscaArquivo()
procura.defineNomeArquivo("*mp3*")
procura.defineDiretorio("/home/daniel/media/mp3")
resultado = procura.buscaArquivo()
SU.printr(resultado)
# procura.buscaConteudo(".", "python")
elif meio == 5: # "texto":
print "texto"
pr = Procura()
pr.procurarPontuar("network", dados.lower())
print "Categoria: ", pr.obtemCategoria().upper()
print "\tPontos: \t[", pr.obtemPontuacao(), "]"
print "\tRelevancia: \t[", pr.fuzzinator().upper(), "]"
print "\tPontos por palavra: \t[", int(pr.obtemPontosPorPalavra()), "]"
# print pr.obtemPalavrasCategoria()
# print pr.obtemNumeroPalavras()
##print pr.obtemPercentualPalavrasCategoria()
#
# print pr.obtemPercentualPalavrasCategoria(), "",pr.obtemPontosPorPalavra(), ""
# print pr.obtemPontosPorPalavraCategoria() , "", pr.obtemPontosCategoria()
else:
print "Opcao Invalida"
print "Fim."
