def compare(html1, html2):
if html1 == html2:
return 1, 1
# print("html1",html1)
# print("html2",html2)
style_rate = style_similarity(html1, html2)
struc_rate = structural_similarity(html1, html2)
return style_rate, struc_rate
def Assess_HTML_SIM(generatedHTML, targetHTML):
from html_similarity import style_similarity, structural_similarity, similarity
print("---------------------------")
print(style_similarity(generatedHTML, targetHTML))
print("---------------------------")
print(structural_similarity(generatedHTML, targetHTML))
print("---------------------------")
print(similarity(generatedHTML, targetHTML))
def _compare_dom_tree(value1, value2):
return 0 if value1 == value2 else 1
# very very slower with very very few accuracy improvement
if value1 == value2:
return 0
try:
return 1 - html_similarity.structural_similarity(value1, value2)
except AttributeError:
return 1
def getDuplicateFiles():
allFilesDetailed = getAllFilesDetailed()
arrOfDuplicate = []
for i in range(0, len(allFilesDetailed)):
for j in range(i + 1, len(allFilesDetailed)):
if structural_similarity(allFilesDetailed[i][1],
allFilesDetailed[j][1]) == 1.0:
arrOfDuplicate.append(allFilesDetailed[i][0])
break
return arrOfDuplicate
def get_dom_sim(pages):
pageCnt = len(pages)
matrix = np.zeros(shape=(pageCnt, pageCnt))
for i in range(pageCnt):
matrix[i][i] = 1
for j in range(i + 1, pageCnt):
sim = structural_similarity(pages[i], pages[j])
matrix[i][j] = sim
matrix[j][i] = sim
return matrix
def compare_resp(flow1, flow2):
f1 = flow.flow(flow1)
f2 = flow.flow(flow2)
#print(f1.resp_type)
#print(f2.resp_type)
#pdb.set_trace()
if f1.resp_type != f2.resp_type:
ctx.log.error('Unexpected response content type!')
return
if f1.resp_type == 'json' and f1.resp_content.keys(
) != f2.resp_content.keys():
ctx.log.error('Different json structure!')
return
elif f1.resp_type == 'html':
sim = hs.structural_similarity(f1.resp_raw, f2.resp_raw)
ctx.log.error(str(sim))
def main(lang1, lang2, url1, url2, file1, file2, enc1, enc2):
if url1 and url2:
html1 = requests.get(url1).content.decode(
enc1, "replace").replace("\n", " ").replace("\t", " ")
html2 = requests.get(url2).content.decode(
enc2, "replace").replace("\n", " ").replace("\t", " ")
else:
html1 = open(file1).read().replace("\n", " ").replace("\t", " ")
html2 = open(file2).read().replace("\n", " ").replace("\t", " ")
url1 = "http://test.com/{:s}".format(lang1)
url2 = "http://test.com/{:s}".format(lang2)
print("style_similarity={:f} structural_similarity={:f} similarity={:f}".format(
style_similarity(html1, html2), structural_similarity(html1, html2), similarity(html1, html2)), file=sys.stderr)
print("\t".join(["dummy_key", lang1, url1, html1, lang2, url2, html2]))
def encuentraArchivoMasParecido(pageRequest):
# Con el siguiente codigo se compara la pagina solicitada con todas las paginas que disponemos en
# WebPageArchive en busca del archivo mas parecido
maxSimil = -1.0
maxSimArchiveName = ""
for fileData in archiveManager.getAllFilesDetailed(
): # Se le pide al gestor de archivos todos los datos/contenidos de las paginas guardadas
comp = structural_similarity(
fileData[1], pageRequest.text
) # Se comapara cada uno de los datos con la pagina solicitada
if maxSimil < comp:
maxSimArchiveName = fileData[
0] # Se almacena cual es el nombre del archivo con similitud mayor para no guardar
maxSimil = comp # la misma pagina en el regstro y se guarda tambien dicha similitud
if maxSimil == 1.0:
break # Si encuentra una similitud de 1 quiere decir que la pagina ya esta en el registro
return maxSimArchiveName, maxSimil
def main():
prevFile = '.'
prevFileName = ""
url = 'https://egela.ehu.eus/?lang=eu' # Esta es la URL de la pagina que se va a obtener
trustUrl = 'google.com'
archiveManager.updateCurrentArchive()
duplicated = archiveManager.getDuplicateFiles()
if duplicated:
print(
"Hay achivos duplicados o muy parecidos, revisa estas direcciones:"
)
for id, directions in enumerate(duplicated):
print("\r", id, ": ", directions)
else:
print("No se han encontrado achivos duplicados o parecidos :,)")
while True:
ping_code = -1
ping_meaning = ""
newFile = False
try:
ping_code, ping_meaning = getPing("egela.ehu.eus", trustUrl)
page = requests.get(
url
) # Se obtiene la pagina como objeto Response y se guarda en la var. page
errors = False
except:
errors = True
if not errors:
if structural_similarity(
prevFile, page.text
) != 1.0: # Se compara el contenido de la pagina actual con la pagina anterior
maxSimArchiveName, maxSimil = encuentraArchivoMasParecido(page)
# Si despues de compararla con todas las almacenadas la mayor similitud es menor entonces:
if maxSimil <= 0.8:
nFileName = 'egel_' + str(int(time.time() // 1)) + '.html'
archiveManager.addArchive(
nFileName, page.text
) # El gestor se encargara de guardar esa pagina
maxSimArchiveName = nFileName
newFile = True
prevFile = page.text
prevFileName = maxSimArchiveName
else:
maxSimArchiveName = prevFileName
maxSimil = 1.0
regEstados.addNewLine(time.strftime("%d/%m/%Y"),
time.strftime("%H:%M:%S"), newFile,
proveIsFallen1(page),
proveIsFallen2(maxSimArchiveName), ping_code,
maxSimArchiveName)
else:
maxSimil = -1.0
regEstados.addNewLine(time.strftime("%d/%m/%Y"),
time.strftime("%H:%M:%S"), newFile, "ERR",
"ERR", ping_code, "ERR")
# en la carpeta de paginas
print(
time.ctime(), "/ Simil:", maxSimil, "/ PingCode:", ping_code,
"; PingMeaning:", ping_meaning
) # Se imprime la similitud para saber que el programa no se ha colgado
time.sleep(10)