def analyzeWithTargets(self, text, name, symbol):
if text == None or text == "":
raise Exception(
"The function analyze() received an None or empty text parameter."
)
try: # With name and symbol targets
response = Watson.natural_language_understanding.analyze(
text=text,
features=Features(
emotion=EmotionOptions(targets=[name, "$" + symbol]),
sentiment=SentimentOptions(targets=[name, "$" + symbol])),
#language="en",
return_analyzed_text=True)
except BaseException as e:
print(e)
try: # Just with name targets
response = Watson.natural_language_understanding.analyze(
text=text,
features=Features(
emotion=EmotionOptions(targets=[name]),
sentiment=SentimentOptions(targets=[name])),
#language="en",
return_analyzed_text=True)
except BaseException as e:
print(e)
try: # Just with symbol targets
response = Watson.natural_language_understanding.analyze(
text=text,
features=Features(
emotion=EmotionOptions(targets=[symbol]),
sentiment=SentimentOptions(targets=[symbol])),
#language="en",
return_analyzed_text=True)
except BaseException as e:
print(e)
try: # Without targets
response = Watson.natural_language_understanding.analyze(
text=text,
features=Features(emotion=EmotionOptions(),
sentiment=SentimentOptions()),
#language="en",
return_analyzed_text=True)
except BaseException as e:
print(e)
return False
print(json.dumps(response, indent=4))
return response
def sentiment_analysis(data):
try:
response = natural_language_understanding.analyze(
text=data, features=Features(sentiment=SentimentOptions()))
return response['sentiment']['document']['label']
except:
return 'unknown'
def main(dict):
try:
model_id=""
natural_language_understanding = NaturalLanguageUnderstandingV1(
version='2018-04-05',
iam_apikey="",
url='')
resposta = natural_language_understanding.analyze(
text=dict['texto'],
features=Features(
entities=EntitiesOptions(emotion=True, sentiment=True, model=model_id),
sentiment=SentimentOptions()),
).get_result()
retorno = {}
# Salvar as entidades no retorno
if 'entities' in resposta:
for i in range(len(resposta['entities'])):
retorno[resposta['entities'][i]['type']] = resposta['entities'][i]['text']
# Salvar o sentimento no retorno
if 'sentiment' in resposta:
retorno['sentiment'] = resposta['sentiment']['document']['label']
dict['err'] = False
dict['resposta'] = retorno
return dict
except:
dict['err'] = True
dict['resposta'] = "Erro na chamada ao NLU."
return dict
def IntelligentCrawlUrl(URL):
"""
This Function uses IBM Watson's Natural Language Understanding API to crawl the links and get company or person names based on a knowledge graph it already has.
This Function also return Company/Person names based on relevance score by IBM Natural Language Cognitive API.
"""
ListOfEntityOutput = []
try:
response = NaturalLanguageUnderstanding.analyze(
url=URL,
features=Features(entities=EntitiesOptions(emotion=True,
sentiment=True,
limit=250),
sentiment=SentimentOptions(),
keywords=KeywordsOptions(emotion=True,
sentiment=True,
limit=250)))
except Exception as e:
response = {}
if response:
for EveryEntity in response["entities"]:
if EveryEntity["type"] == "Company":
if EveryEntity["relevance"] > 0.25:
ListOfEntityOutput.append(EveryEntity["text"])
print(ListOfEntityOutput)
return ListOfEntityOutput
def IBMNonTran(df):
natural_language_understanding = NaturalLanguageUnderstandingV1(
version='2019-07-12',
iam_apikey='v8j7M76fx4hOFr35AhLUso35qgmsocV5_WM-Ag0IdKg5',
url=
'https://api.us-south.natural-language-understanding.watson.cloud.ibm.com/instances/dbf791a6-366c-48d9-81ac-9a08ac7f130c'
)
ibm = []
i = 0
x = 0.5
for i in range(0, len(df)):
try:
response = natural_language_understanding.analyze(
language=df['langCode'][i],
text=str(df['review_body'][i]),
features=Features(sentiment=SentimentOptions())).get_result()
res = response.get('sentiment').get('document').get('score')
ibm.append(res)
except:
ibm.append('NA')
df['ibm1'] = ibm
return df
def analyze_text(self, text):
if len(text) > 15:
response = self.natural_language_understanding.analyze(
text=text,
features=Features(sentiment=SentimentOptions(),
emotion=EmotionOptions())).get_result()
print(json.dumps(response, indent=2))
else:
response = {
"usage": {
"text_units": 1,
"text_characters": 65,
"features": 2
},
"sentiment": {
"document": {
"score": 0.0,
"label": "neutral"
}
},
"language": "en",
"emotion": {
"document": {
"emotion": {
"sadness": 0.0,
"joy": 0.0,
"fear": 0.0,
"disgust": 0.0,
"anger": 0.0
}
}
}
}
return response
def SentimentClassify(target_text):
response_senti = natural_language_understanding.analyze(
text=target_text,
features=Features(sentiment=SentimentOptions()),
language=TextBlob(target_text).detect_language()).get_result()
sentiscore = response_senti["sentiment"]["document"]["score"]
return sentiscore
def getres(file_loc):
with open(file_loc, 'r+') as f:
head = f.readline()
content = f.read()
req = '<html><body><h2>{0}</h2>{1}</body></html>'.format(head, content)
text = head + content
tone_res = tone_analyzer.tone(req, content_type='text/html').get_result()
res = natural_language_understanding.analyze(
html=req,
features=Features(
categories=CategoriesOptions(limit=1),
concepts=ConceptsOptions(limit=5),
keywords=KeywordsOptions(limit=5, sentiment=True, emotion=True),
sentiment=SentimentOptions(),
# entities=EntitiesOptions(limit=5, mentions=True, sentiment=True, emotion=True),
),
).get_result()
sentiment = res["sentiment"]["document"]["score"]
concepts = [(concepts["text"], concepts["relevance"])
for concepts in res["concepts"]]
categories = (res["categories"][0]["label"].split("/"),
res["categories"][0]["score"])
keywords = [(keywords["text"], keywords["relevance"])
for keywords in res["keywords"]]
tones = [(tone["tone_id"], tone["score"])
for tone in tone_res["document_tone"]["tones"]]
return (sentiment, concepts, keywords, tones, text)
def concepts(self):
IBM_dict = {}
IBM_response = self.naturalLanguageUnderstanding.analyze(
text=self.text,
features=Features(
entities=EntitiesOptions(emotion=True, sentiment=True, limit=10),
keywords=KeywordsOptions(emotion=True, sentiment=True,limit=10),
sentiment=SentimentOptions(),
categories=CategoriesOptions()
)).get_result()
sent_dict = {'sentiment': IBM_response['sentiment']['document']['score']}
IBM_dict['sentiment'] = sent_dict
ent_result = []
ents = IBM_response['entities']
for e in ents:
ent_result.append(e['text'].lower())
ent_result.sort()
IBM_dict['entities'] = ent_result
kws = []
for keyword in IBM_response['keywords']:
kws.append(keyword['text'].lower())
kws.sort()
IBM_dict['keywords'] = kws
cats = []
for category in IBM_response['categories']:
cats.append(category['label'])
IBM_dict['categories'] = cats
return IBM_dict
def get_average_sentiment():
print(request.get_json(force=True))
company = request.get_json()['company']
print(company_dict[company])
url = ('https://newsapi.org/v2/everything?'
'q="' + company_dict[company] + '"&'
'from=2018-10-10&'
'sortBy=relevancy&'
'apiKey=accb9b5d018348ff86fd7f9565673758&'
'language=en'
'&pageSize=5')
response = requests.get(url)
response = response.json()
#print(response)
if 'articles' in response:
articles = response['articles']
else:
articles = []
avg = 0
for article in articles:
try:
response = natural_language_understanding.analyze(
url=article['url'],
features=Features(sentiment=SentimentOptions())).get_result()
avg += response['sentiment']['document']['score']
except:
print("Error")
return jsonify({ "sentiment": avg / 5 })
def process_text(self, conv):
unicodedata.normalize('NFKD', conv).encode('ascii', 'ignore')
nlp = self.nlp_api.analyze(
text=conv,
language='es',
features=Features(keywords=KeywordsOptions(emotion=True,
sentiment=True),
categories=CategoriesOptions(),
sentiment=SentimentOptions(targets=self.flags)))
if self.log_file != None:
print('INFO: logging NLP to %s\n' % self.log_file)
with open(self.log_file, 'w') as outfile:
json.dump(nlp, outfile)
doc_score = 0
target_score = []
try:
doc_score = nlp['sentiment']['document']['score']
for target in nlp['sentiment']['targets']:
target_score.append({
'text': target['text'],
'score': target['score']
})
except KeyError:
print('INFO: no target found')
return doc_score, target_score
def watson_nlp_analysis(text):
if text == '': return text
max_limit_one = 10
max_limit_two = 30
naturalLanguageUnderstanding = NaturalLanguageUnderstandingV1(
version='2018-11-16',
iam_apikey=os.environ['WATSON'],
url=
'https://gateway.watsonplatform.net/natural-language-understanding/api'
)
response = naturalLanguageUnderstanding.analyze(
text=text,
features=Features(concepts=ConceptsOptions(limit=max_limit_one),
categories=CategoriesOptions(limit=max_limit_one),
sentiment=SentimentOptions(document=True),
emotion=EmotionOptions(document=True),
entities=EntitiesOptions(emotion=True,
sentiment=True,
limit=max_limit_two),
keywords=KeywordsOptions(
emotion=True,
sentiment=True,
limit=max_limit_two))).get_result()
return response
def understanding(self):
if not self.transcription:
self.transcript()
natural_language_understanding = NaturalLanguageUnderstandingV1(
version='2017-02-27',
username=os.environ['UNDERSTANDING_USERNAME'],
password=os.environ['UNDERSTANDING_PASSWORD'])
self.analysis = natural_language_understanding.analyze(
text=self.transcription['results'][0]['alternatives'][0]
['transcript'],
features=Features(categories=CategoriesOptions(),
concepts=ConceptsOptions(),
emotion=EmotionOptions(),
entities=EntitiesOptions(emotion=True,
sentiment=True,
mentions=True),
keywords=KeywordsOptions(emotion=True,
sentiment=True),
relations=RelationsOptions(),
sentiment=SentimentOptions()))
logger.info('Completed analysis of recorded file')
return self.analysis
def sentiment(input):
try:
#using IBM Watson
response = naturalLanguageUnderstanding.analyze(
text=input,
#an object that is part of Watson API
features=Features(
sentiment=SentimentOptions(document=None, targets=None))
).get_result()
#not sure why dumping and immedietly loading?
#is it a formatting reason?
parsed_json = json.loads(json.dumps(response, indent=2))
#sentiment: negative, 0, or positive
sentiment = parsed_json['sentiment']
document = sentiment['document']
score = document['score']
sentiment_value = float(score)
except:
#use nltk instead
sentiment_value = sid().polarity_scores(input)['compound']
print(sentiment_value)
react_with_sound(sentiment_value)
return 6
def handleMoodLogging():
# Display the form
if request.method == 'GET':
return render_template('index.html')
else:
# Validate using credentials
natural_language_understanding = NaturalLanguageUnderstandingV1(
username=secret_dictionary['username'],
password=secret_dictionary['password'],
version='2018-03-16')
# Grab the text from the user
journal_contents = request.form['journal_content']
#print('journal contents: ', journal_contents.encode('ascii', 'ignore'))
# Make a call to the API with the text passed in
alchemy_results = natural_language_understanding.analyze(
text=journal_contents.encode('ascii', 'ignore'),
features=Features(emotion=EmotionOptions(),
sentiment=SentimentOptions()))
#print 'Writing results to a file:'
fo = open('static/mockresponses/emotion_response.json', 'w+')
fo.write(json.dumps(alchemy_results, indent=2))
fo.close()
return render_template('gauge.html')
def get_sentiment(self, song, artist):
warnings.filterwarnings('ignore')
natural_language_understanding = NaturalLanguageUnderstandingV1(
version='2017-02-27', username="******", password="******")
response = natural_language_understanding.analyze(
text=PyLyrics.getLyrics(artist, song),
features=Features(emotion=EmotionOptions(),
sentiment=SentimentOptions()))
return response.get('sentiment').get('document').get('score')
def __init__(self):
self.naturalLanguageUnderstanding = NaturalLanguageUnderstandingV1(
version='2018-09-21',
iam_apikey='z22B_pFOjawl36w4CwyWGRs55jVnXE4y464VlyY7o-67',
url=
'https://gateway-syd.watsonplatform.net/natural-language-understanding/api'
)
self.def_features = Features(sentiment=SentimentOptions(document=True),
emotion=EmotionOptions(document=True))
def analizarTexto(USER):
#Open the file with the name of the user.
resultfile = open("result_"+USER+".json", "w+")
targets =[
'vida', 'Guatemala', 'amor', 'sexo', 'politico',
'poliltica','Yo', 'sonrisa', 'pais','novio','novia',
'enojo', 'hermano', 'hermana','mama','papa','familia',
'deporte', 'relacion'
]
#Get the configuration file
with open('config.json', 'r') as f:
config = json.load(f)
#reading the data file
datafile = open("data_" +USER+".txt","r")
data = datafile.read()
#print the data... remove this..
print (data)
#Authentication
natural_language_understanding = NaturalLanguageUnderstandingV1(
version=config["version"],
username=config["username"],
password=config["password"]
)
response = natural_language_understanding.analyze(
text=data,
features=Features(
entities=EntitiesOptions(
emotion=True,
sentiment=True,
limit=2),
keywords=KeywordsOptions(
emotion=True,
sentiment=True,
limit=2),
sentiment=SentimentOptions(
targets=targets
)
#Doesn't support spanish language yet
# ,
# emotion=EmotionOptions(
# targets=targets
# )
)
)
result = str(response)
print (result)
resultfile.write(result + "")
resultfile.close()
f.close()
datafile.close()
def get_label(text):
try:
response = natural_language_understanding.analyze(
text=text,
features=Features(sentiment=SentimentOptions())).get_result()
return response['sentiment']['document']['label']
except:
return 'neutral'
def analyzeSentiment(absUrl):
"""
Analyzes content for general sentiment/tone
:param absUrl: Article Url
:returns: floating point value between -1 and 1. -1 being most negative and
1 being most positive.
"""
response = natural_language_understanding.analyze(
url=absUrl, features=Features(sentiment=SentimentOptions()))
return response['sentiment']['document']['score']
def get_ibm_sent(text_sample):
'''
Analyze sentiment using IBM nlp API
'''
response = natural_language_understanding.analyze(
text=text_sample, features=Features(sentiment=SentimentOptions()))
score = response["sentiment"]["document"]["score"]
#print(json.dumps(response, indent=2))
return score
def analyze_sentiment(news):
if news['title']:
analysis = natural_language_understanding.analyze(
text=news['title'],
features=Features(sentiment=SentimentOptions())).get_result()
analyzed = json.dumps(analysis['sentiment']['document']['score'])
return analyzed
else:
return ' '
def sentiment(text):
try:
response = nlu.analyze(text=text,
features=Features(sentiment=SentimentOptions()))
sentiment = json.dumps(response['sentiment']['document']['label'])
except Exception as e:
print(e)
sentiment = "No Enough Text"
return sentiment.strip('"')
def get_news_sentiment(request):
try:
response = natural_language_understanding.analyze(
url=request.GET.get('url'),
features=Features(sentiment=SentimentOptions(),
emotion=EmotionOptions(),
concepts=ConceptsOptions(limit=5),
categories=CategoriesOptions()))
return Response(response)
except:
return Response({"error": 'problem retrieving'})
def analyze_sentiment(self, tweet):
if 'Samsung' in tweet['text']:
analysis = natural_language_understanding.analyze(
text=tweet['text'],
features=Features(sentiment=SentimentOptions(
targets=['Samsung']))).get_result()
analyzed = json.dumps(analysis['sentiment']['targets'][0]['score'])
return analyzed
else:
return ' '
def getSentient(data):
natural_language_understanding = NaturalLanguageUnderstandingV1(
version='2017-02-27',
username='******',
password='******')
response = natural_language_understanding.analyze(
text=data,
features=Features(entities=EntitiesOptions(), sentiment=SentimentOptions()))
print (json.dumps(response,indent=2))
return (json.dumps(response, indent=2))
def get_keywords(self, sentence):
response = self.natural_language_understanding.analyze(
text=sentence,
return_analyzed_text='True',
features=Features(concepts=ConceptsOptions(),
categories=CategoriesOptions(),
relations=RelationsOptions(),
semantic_roles=SemanticRolesOptions(),
sentiment=SentimentOptions(),
entities=EntitiesOptions(),
keywords=KeywordsOptions())).get_result()
keywords = map(lambda x: (x['text'], x['type']), response['entities'])
return keywords
def getScore(self, articleurl): try: response = natural_language_understanding.analyze( url=articleurl, features=Features( sentiment=SentimentOptions()), language='en') #print(json.dumps(response, indent=2)) return response['sentiment']['document']['score'] except Exception: return 0
def analyze_using_NLU(analysistext):
res = dict()
response = natural_language_understanding.analyze(
text=analysistext,
features=Features(sentiment=SentimentOptions(),
entities=EntitiesOptions(),
keywords=KeywordsOptions(),
emotion=EmotionOptions(),
concepts=ConceptsOptions(),
categories=CategoriesOptions(),
semantic_roles=SemanticRolesOptions()))
res['results'] = response
return json.dumps(res)
def test_text_analyze(self):
nlu_url = "http://bogus.com/v1/analyze"
responses.add(responses.POST,
nlu_url,
body="{\"resulting_key\": true}",
status=200,
content_type='application/json')
nlu = NaturalLanguageUnderstandingV1(version='2016-01-23',
url='http://bogus.com',
username='******',
password='******')
nlu.analyze(Features(sentiment=SentimentOptions()),
text="hello this is a test")
assert len(responses.calls) == 1
