# -*- coding: utf-8 -*-

import sys
import codecs
import nltk
import math
from nltk import bigrams
from operator import attrgetter

class DatiBigramma:
bigramma = ('','')
frequenza = 0.0
forzaAssociativa = 0.0

def analisiLinguistica(frasi):
tokens = []
tokensPOS = []
entitaPersona = []
entitaLuogo = []
bigrammi = []
for frase in frasi:
tok = nltk.word_tokenize(frase)
tokens = tokens + tok
tokensPOS = nltk.pos_tag(tokens)
bigrammi = bigrams(tokensPOS)
# Analisi name entity
analisi = nltk.ne_chunk(tokensPOS)
for nodo in analisi:
if hasattr(nodo, "node"):
if nodo.node in ["PERSON"]:
for partNE in nodo.leaves():
entitaPersona.append((partNE[0], nodo.node))
if nodo.node in ["GPE"]:
for partNE in nodo.leaves():
entitaLuogo.append((partNE[0], nodo.node))
return tokens, tokensPOS, entitaPersona, entitaLuogo, bigrammi

def calcolaMarkovUno(lunghezzaCorpus, distrFrequenzaBigrammi, distrFrequenza,

bigrammiFrase):
probabilita = distrFrequenza[bigrammiFrase[0][0]]
for big in bigrammiFrase:
if distrFrequenza[big[0]] != 0:
probabilitaBig = float(float(distrFrequenzaBigrammi[big])/float(distrFrequenza[big[0]]))
else:
probabilitaBig = 0
probabilita = probabilita * probabilitaBig
return probabilita
def tokenizza(frasi):
tokens = []
for frase in frasi:
tok = nltk.word_tokenize(frase)
tokens = tokens + tok
return tokens

# Controlla che le occorrenze nel testo di ogni token della frase siano almeno 2
def occorrenzeTokensFraseMaggioriUno(fraseTokenizzata, listaTokens):
for token in fraseTokenizzata:
if listaTokens.count(token) < 2:
return False
return True

def main(obama, romney):

bigrammiAnalizzatiObama = []
bigrammiAnalizzatiRomney = []
nomiAggettivi = ['JJ','JJR','JJS','NN' ,'NNS','NP','NPS']
indice = 0
# Leggo file in input
fileObama = codecs.open(obama, "r", "utf-8")
fileRomney = codecs.open(romney, "r", "utf-8")
rawObama = fileObama.read()
rawRomney = fileRomney.read()
# carico il teokenizzatore di nltk
tokenizzatore = nltk.data.load('tokenizers/punkt/english.pickle')

# divido il file in frasi

frasiObama = tokenizzatore.tokenize(rawObama)
frasiRomney = tokenizzatore.tokenize(rawRomney)

# estraggo i tokens del testo

tokensObama, posObama, nePersoneObama, neLuoghiObama, bigrammiPosObama =
analisiLinguistica(frasiObama)
tokensRomney, posRomney, nePersoneRomney, neLuoghiRomney, bigrammiPosRomney =
analisiLinguistica(frasiRomney)
nePersoneObama = nltk.FreqDist(nePersoneObama)
neLuoghiObama = nltk.FreqDist(neLuoghiObama)
nePersoneRomney = nltk.FreqDist(nePersoneRomney)
neLuoghiRomney = nltk.FreqDist(neLuoghiRomney)

# Estraggo e ordino i tokens più frequenti

distribuzioneObama = nltk.FreqDist(tokensObama)
distribuzioneRomney = nltk.FreqDist(tokensRomney)

# Estraggo e ordino i POS più frequenti

classiPosObama = []
 classiPosRomney = []
for classePOS in posObama:
classiPosObama.append(classePOS[1])
for classePOS in posRomney:
classiPosRomney.append(classePOS[1])
distribuzionePOSObama = nltk.FreqDist(classiPosObama)
distribuzionePOSRomney = nltk.FreqDist(classiPosRomney)

# ESTRAGGO E ANALIZZO I BIGRAMMI DI OBAMA

bigrammiObama = bigrams(tokensObama)
bigrammiObamaFiltrati = []
for bigramma in bigrammiPosObama:
# Filtro 1: Frequenze maggiori di 2
if tokensObama.count(bigramma[0][0]) >= 2 and tokensObama.count(bigramma[1][0]) >= 2:
parola1Pos = bigramma[0][1]
parola2Pos = bigramma[1][1]
# Filtro 2: Nomi e/o Aggettivi
if parola1Pos in nomiAggettivi and parola2Pos in nomiAggettivi:
bigrammiObamaFiltrati.append(bigramma)
bigrammiObamaFiltrati = set(bigrammiObamaFiltrati)
# Estraggo i dati dei bigrammi di Obama
for bigramma in bigrammiObamaFiltrati:
bigrammaAttuale = DatiBigramma()
big1 = bigramma[0][0]
big2 = bigramma[1][0]
bigrammaAttuale.bigramma = (big1, big2)
bigrammaAttuale.frequenza = bigrammiObama.count(bigrammaAttuale.bigramma)
# Calcolo della LMI del bigramma
dividendo = float(float(bigrammaAttuale.frequenza) * float(len(tokensObama)))
divisore =
float(tokensObama.count(bigrammaAttuale.bigramma[0]))*float(tokensObama.count(bigrammaA
ttuale.bigramma[1]))
bigrammaAttuale.forzaAssociativa = float((math.log((float(dividendo)/float(divisore)), 2))) *
float(bigrammaAttuale.frequenza)
if not(bigrammaAttuale in bigrammiAnalizzatiObama):
bigrammiAnalizzatiObama.append(bigrammaAttuale)
bigrammiAnalizzatiObama = sorted(bigrammiAnalizzatiObama, key=attrgetter('frequenza',
'forzaAssociativa'), reverse=True)

# Probabilità frasi con modello di Markov ordine Uno OBAMA

lunghezzaCorpusObama = len(tokensObama)
distrFreqTokensObama = nltk.FreqDist(tokensObama)
distrFreqBigrammiObama = nltk.FreqDist(bigrammiObama)
probabilitaMassimaObama = 0
fraseObamaProbabilitaMassima = ''
for frase in frasiObama:
tokensFraseObama = nltk.word_tokenize(frase)
# Se la frase ha almeno 8 tokens e le occorrenze nel testo di ogni token sono almeno 2
 if len(tokensFraseObama) >= 8 and occorrenzeTokensFraseMaggioriUno(tokensFraseObama,
tokensObama):
bigrammiFraseObama = bigrams(tokensFraseObama)
probabilitaFraseObama = calcolaMarkovUno(lunghezzaCorpusObama,
distrFreqBigrammiObama, distrFreqTokensObama, bigrammiFraseObama)
if probabilitaFraseObama > probabilitaMassimaObama:
probabilitaMassimaObama = probabilitaFraseObama
fraseObamaProbabilitaMassima = frase

# ESTRAGGO E ANALIZZO I BIGRAMMI DI ROMNEY

bigrammiRomney = bigrams(tokensRomney)
bigrammiRomneyFiltrati = []
for bigramma in bigrammiPosRomney:
if tokensRomney.count(bigramma[1][0]) >= 2 and tokensRomney.count(bigramma[1][0]) >= 2:
parola1Pos = bigramma[0][1]
parola2Pos = bigramma[1][1]
if parola1Pos in nomiAggettivi and parola2Pos in nomiAggettivi:
bigrammiRomneyFiltrati.append(bigramma)
bigrammiRomneyFiltrati = set(bigrammiRomneyFiltrati)
# Estraggo i dati dei bigrammi di Romney
for bigramma in bigrammiRomneyFiltrati:
bigrammaAttuale = DatiBigramma()
big1 = bigramma[0][0]
big2 = bigramma[1][0]
bigrammaAttuale.bigramma = (big1, big2)
bigrammaAttuale.frequenza = bigrammiRomney.count(bigrammaAttuale.bigramma)
# Calcolo della LMI del bigramma
dividendo = float(float(bigrammaAttuale.frequenza) * float(len(tokensRomney)))
divisore =
float(tokensRomney.count(bigrammaAttuale.bigramma[0]))*float(tokensRomney.count(bigramm
aAttuale.bigramma[1]))
bigrammaAttuale.forzaAssociativa = float((math.log((float(dividendo)/float(divisore)), 2))) *
float(bigrammaAttuale.frequenza)
if not(bigrammaAttuale in bigrammiAnalizzatiRomney):
bigrammiAnalizzatiRomney.append(bigrammaAttuale)
bigrammiAnalizzatiRomney = sorted(bigrammiAnalizzatiRomney, key=attrgetter('frequenza',
'forzaAssociativa'), reverse=True)

# Probabilità frasi con modello di Markov ordine Uno ROMNEY

lunghezzaCorpusRomney = len(tokensRomney)
distrFreqTokensRomney = nltk.FreqDist(tokensRomney)
distrFreqBigrammiRomney = nltk.FreqDist(bigrammiRomney)
probabilitaMassimaRomney = 0
fraseRomneyProbabilitaMassima = ''
for frase in frasiRomney:
tokensFraseRomney = nltk.word_tokenize(frase)
# Se la frase ha almeno 8 tokens e le occorrenze nel testo di ogni token sono almeno 2
 if len(tokensFraseRomney) >= 8 and
occorrenzeTokensFraseMaggioriUno(tokensFraseRomney, tokensRomney):
bigrammiFraseRomney = bigrams(tokensFraseRomney)
probabilitaFraseRomney = calcolaMarkovUno(lunghezzaCorpusRomney,
distrFreqBigrammiRomney, distrFreqTokensRomney, bigrammiFraseRomney)
if probabilitaFraseRomney > probabilitaMassimaRomney:
probabilitaMassimaRomney = probabilitaFraseRomney
fraseRomneyProbabilitaMassima = frase

print "OBAMA"
print "Primi 20 tokens più frequenti:"
for element in distribuzioneObama:
if indice < 20:
print element, distribuzioneObama[element]
indice = indice + 1
print
print "Primi 10 POS:"
indice = 0
for element in distribuzionePOSObama:
if indice < 10:
print element, distribuzionePOSObama[element]
indice = indice + 1
print
indice = 0
print "Primi 10 Bigrammi in ordine di frequenza e forza associativa"
for element in bigrammiAnalizzatiObama:
if indice < 10:
print element.bigramma, "Freq:", element.frequenza, "LMI", element.forzaAssociativa
indice = indice + 1
print
print "Frase con probabilita massima:", fraseObamaProbabilitaMassima
print "Luoghi e persone nominati da Obama"
print "PERSONE"
for persone in nePersoneObama:
print persone, nePersoneObama[persone]
print "LUOGHI"
for luoghi in neLuoghiObama:
print luoghi, neLuoghiObama[luoghi]

indice = 0
print
print "************************************************************"
print
print "ROMNEY"
print "Primi 20 tokens più frequenti:"
for element in distribuzioneRomney:
if indice < 20:
print element, distribuzioneRomney[element]
 indice = indice + 1
indice = 0
print
print "Primi 10 POS:"
for element in distribuzionePOSRomney:
if indice < 10:
print element, distribuzionePOSRomney[element]
indice = indice + 1
print
indice = 0
print "Primi 10 Bigrammi in ordine di frequenza e forza associativa"
for element in bigrammiAnalizzatiRomney:
if indice < 10:
print element.bigramma, "Freq:", element.frequenza, "LMI", element.forzaAssociativa
indice = indice + 1
print
print "Frase con probabilita massima:", fraseRomneyProbabilitaMassima
print "Luoghi e persone nominati da Romney"
print "PERSONE"
for persone in nePersoneRomney:
print persone, nePersoneRomney[persone]
print "LUOGHI"
for luoghi in neLuoghiRomney:
print luoghi, neLuoghiRomney[luoghi]

main(sys.argv[1], sys.argv[2])