def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create default file to read from
f = tempfile.NamedTemporaryFile(suffix=".html")
sentiment_file_data = "<html><head><title>New Ghostbusters Film</title></head><body><p>Original Ghostbuster Dan Aykroyd, who also co-wrote the 1984 Ghostbusters film, couldn’t be more pleased with the new all-female Ghostbusters cast, telling The Hollywood Reporter, “The Aykroyd family is delighted by this inheritance of the Ghostbusters torch by these most magnificent women in comedy.”</p></body></html>"
message = sentiment_file_data
f.write(message)
f.seek(0)
# Create an API instance
api = API(user_key=key, service_url=altUrl)
params = DocumentParameters()
params["language"] = "eng"
# Use an HTML file to load data instead of a string
params.load_document_file(f.name)
try:
result = api.sentiment(params)
except RosetteException as e:
print(e)
finally:
# Clean up the file
f.close()
return result
def test_debug():
# Doesn't really matter what it returns for this test, so just making sure it catches all of them
endpoints = ["categories", "entities", "entities/linked", "language", "matched-name", "morphology-complete",
"sentiment", "translated-name", "relationships"]
expected_status_filename = response_file_dir + "eng-sentence-entities.status"
expected_output_filename = response_file_dir + "eng-sentence-entities.json"
for rest_endpoint in endpoints:
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/" + rest_endpoint,
status=get_file_content(expected_status_filename),
body=get_file_content(expected_output_filename),
content_type="application/json")
with open(expected_output_filename, "r") as expected_file:
expected_result = json.loads(expected_file.read())
# need to mock /info call too because the api will call it implicitly
with open(response_file_dir + "info.json", "r") as info_file:
body = info_file.read()
httpretty.register_uri(httpretty.GET, "https://api.rosette.com/rest/v1/info",
body=body, status=200, content_type="application/json")
httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info",
body=body, status=200, content_type="application/json")
api = API("0123456789", debug=True)
content = "He also acknowledged the ongoing U.S. conflicts in Iraq and Afghanistan, noting that he is the \"commander in chief of a country that is responsible for ending a war and working in another theater to confront a ruthless adversary that directly threatens the American people\" and U.S. allies."
params = DocumentParameters()
params.__setitem__("content", content)
api.entities(params)
# Check that the most recent querystring had debug=true
assert httpretty.last_request().querystring == {'debug': ['true']}
def run(key, alt_url='https://api.rosette.com/rest/v1/'):
""" Run the example """
# Create default file to read from
temp_file = tempfile.NamedTemporaryFile(suffix=".html")
sentiment_file_data = "<html><head><title>New Ghostbusters Film</title></head><body><p>Original Ghostbuster Dan Aykroyd, who also co-wrote the 1984 Ghostbusters film, couldn’t be more pleased with the new all-female Ghostbusters cast, telling The Hollywood Reporter, “The Aykroyd family is delighted by this inheritance of the Ghostbusters torch by these most magnificent women in comedy.”</p></body></html>"
message = sentiment_file_data
temp_file.write(
message if isinstance(message, bytes) else message.encode())
temp_file.seek(0)
# Create an API instance
api = API(user_key=key, service_url=alt_url)
# Set selected API options.
# For more information on the functionality of these
# and other available options, see Rosette Features & Functions
# https://developer.rosette.com/features-and-functions#sentiment-analysis
# api.set_option('modelType','dnn') #Valid for English only
params = DocumentParameters()
params["language"] = "eng"
# Use an HTML file to load data instead of a string
params.load_document_file(temp_file.name)
try:
result = api.sentiment(params)
except RosetteException as exception:
print(exception)
finally:
# Clean up the file
temp_file.close()
return result
def get_basis_sentiment(self, txt_str):
params = DocumentParameters()
params["language"] = "eng"
# Use an HTML file to load data instead of a string
params.load_document_string(txt_str)
try:
result = self.rosette_handle.sentiment(params)
except RosetteException as e:
print(e)
finally:
print " DONE "
def get_basis_categories(self, txt_str):
# if self.DO_NOT_CALL == True:
# return "POS"
params = DocumentParameters()
params["language"] = "eng"
# Use an HTML file to load data instead of a string
params.load_document_string(txt_str)
typed_relations_resp = self.rosette_handle.categories(text=txt_str)
print " >>> CALLED IBM - typed_relations_resp: " + str(
typed_relations_resp)
return json.dumps(typed_relations_resp)
def get_vector(folder, file):
f = open(folder + file, "r")
embeddings_data = f.read()
api = API(user_key="", service_url="http://localhost:8181/rest/v1/")
params = DocumentParameters()
params["content"] = embeddings_data
try:
vector = api.text_embedding(params)
save_vector(file, vector, "doc", "")
except RosetteException as exception:
print(exception)
except:
print('unkown error in get vector')
try:
sentences = api.sentences(params)
sentences = sentences.get('sentences')
for x in sentences:
params["content"] = x
sentence_vector = api.text_embedding(params)
save_vector(file, sentence_vector, "sen", x)
except RosetteException as exception:
print(exception)
except:
print('unkown sentence error')
def analyse_rosette(self, tweet):
params = DocumentParameters()
params["content"] = tweet
params["genre"] = "social-media"
extracted_entities = []
try:
entities = self.rosette.entities(params)
for entity in entities['entities']:
doc = {
"entity": entity['mention'].lower(),
"type": entity["type"],
}
if "confidence" in entity:
doc["certainty"] = entity["confidence"]
extracted_entities.append(doc)
elif "linkingConfidence" in entity:
doc["certainty"] = entity["linkingConfidence"]
extracted_entities.append(doc)
return extracted_entities
except RosetteException as exception:
warns = ['meaningful', 'Language']
# if ['meaningful', 'Language'] not in exception.message:
if not any(warn in exception.message for warn in warns):
raise RosetteException(
status=exception.status,
message=exception.message,
response_message=exception.response_message)
else:
return []
def get_label(alt_url='https://api.rosette.com/rest/v1/',
sentence="Default Sentence"):
api = API(user_key=API_KEYS.ROSETTE_API_KEY, service_url=alt_url)
params = DocumentParameters()
label_set = set()
final_response_list = []
params["content"] = sentence
params["language"] = "eng"
# params["modelType"] = "dnn"
try:
response_dict = json.loads(json.dumps(
api.sentiment(params)))["document"]
response_list = []
if str(response_dict["label"]) == "pos":
response_list.append(
["POSITIVE", float(response_dict["confidence"])])
elif str(response_dict["label"]) == "neg":
response_list.append(
["NEGATIVE", float(response_dict["confidence"])])
else:
response_list.append(
["NEUTRAL", float(response_dict["confidence"])])
# ["sentiment"]
# print response_dict
return response_list[0]
except RosetteException as exception:
print(exception)
def request(content, endpoint, api, language=None, uri=False, **kwargs):
"""Request Rosette API results for the given content and endpoint.
This method gets the requested results from the Rosette API as JSON. If
api's output parameter has been set to "rosette" then the JSON will consist
of an A(nnotated) D(ata) M(odel) or ADM. An ADM is a Python dict
representing document content, annotations of the document content,
and document metadata.
content: path or URI of a document for the Rosette API to process
endpoint: a Rosette API endpoint string (e.g., 'entities')
(see https://developer.rosette.com/features-and-functions)
api: a rosette.api.API instance
(e.g., API(user_key=<key>, service_url=<url>))
language: an optional ISO 639-2 T language code
(the Rosette API will automatically detect the language of the
content by default)
uri: specify that the content is to be treated as a URI and the
the document content is to be extracted from the URI
kwargs: additional keyword arguments
(e.g., if endpoint is 'morphology' you can specify facet='lemmas';
see https://developer.rosette.com/features-and-functions for
complete documentation)
"""
parameters = DocumentParameters()
if uri:
parameters['contentUri'] = content
else:
parameters['content'] = content
parameters['language'] = language
try:
adm = methodcaller(endpoint, parameters, **kwargs)(api)
return adm
except RosetteException as e:
print(f'[{e.status}]: {e.message}', file=sys.stderr)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
embeddings_data = "Cambridge, Massachusetts"
params = DocumentParameters()
params["content"] = embeddings_data
return api.text_embedding(params)
def get_label(alt_url='https://api.rosette.com/rest/v1/', sentence = "Default Sentence"):
api = API(user_key=API_KEYS.ROSETTE_API_KEY, service_url=alt_url)
params = DocumentParameters()
label_set = set()
final_response_list = []
params["content"] = sentence
params["language"] = "eng"
try:
response_dict = json.loads(json.dumps(api.categories(params)))["categories"]
response_list = []
for item in response_dict:
response_list.append([str(item["label"]).replace("_", " "), float(item["confidence"])])
response_list_sorted = sorted(response_list, key=getKey, reverse=True)
for item in response_list_sorted:
label = item[0]
if not label in label_set:
final_response_list.append(item)
label_set.add(label)
return final_response_list[:5]
except RosetteException as exception:
print(exception)
def runRosette(text, key, alt_url='https://api.rosette.com/rest/v1/'):
""" Run the example """
# Create default file to read from
temp_file = tempfile.NamedTemporaryFile(suffix=".html")
sentiment_file_data = "<html><head><title></title></head><body><p>" + text + "</p></body></html>"
message = sentiment_file_data
temp_file.write(
message if isinstance(message, bytes) else message.encode())
temp_file.seek(0)
# Create an API instance
api = API(user_key=key, service_url=alt_url)
params = DocumentParameters()
params["language"] = "eng"
params["content"] = text
# Use an HTML file to load data instead of a string
#params.load_document_file(temp_file.name)
try:
result = api.sentiment(params)
#print (result)
except RosetteException as exception:
print(exception)
finally:
# Clean up the file
temp_file.close()
return result
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
tokens_data = "北京大学生物系主任办公室内部会议"
params = DocumentParameters()
params["content"] = tokens_data
return api.tokens(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_compound_components_data = "Rechtsschutzversicherungsgesellschaften"
params = DocumentParameters()
params["content"] = morphology_compound_components_data
return api.morphology(params, MorphologyOutput.COMPOUND_COMPONENTS)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_han_readings_data = "北京大学生物系主任办公室内部会议"
params = DocumentParameters()
params["content"] = morphology_han_readings_data
return api.morphology(params, MorphologyOutput.HAN_READINGS)
def vectorize_text(text, key, url='https://api.rosette.com/rest/v1/'):
"""
Return the vector representation of the input text (as a list of floats).
"""
api = API(user_key=key, service_url=url)
params = DocumentParameters()
params["content"] = text
return api.text_embedding(params)["embedding"]
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
entities_text_data = "Bill Murray will appear in new Ghostbusters film: Dr. Peter Venkman was spotted filming a cameo in Boston this… http://dlvr.it/BnsFfS"
params = DocumentParameters()
params["content"] = entities_text_data
params["genre"] = "social-media"
return api.entities(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_lemmas_data = "The fact is that the geese just went back to get a rest and I'm not banking on their return soon"
params = DocumentParameters()
params["content"] = morphology_lemmas_data
return api.morphology(params, MorphologyOutput.LEMMAS)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_complete_data = "The quick brown fox jumped over the lazy dog. Yes he did."
params = DocumentParameters()
params["content"] = morphology_complete_data
return api.morphology(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
relationships_text_data = "The Ghostbusters movie was filmed in Boston."
params = DocumentParameters()
params["content"] = relationships_text_data
api.setOption('accuracyMode', 'PRECISION')
return api.relationships(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
sentences_data = "This land is your land. This land is my land\nFrom California to the New York island;\nFrom the red wood forest to the Gulf Stream waters\n\nThis land was made for you and Me.\n\nAs I was walking that ribbon of highway,\nI saw above me that endless skyway:\nI saw below me that golden valley:\nThis land was made for you and me."
params = DocumentParameters()
params["content"] = sentences_data
return api.sentences(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
language_data = "Por favor Señorita, says the man."
params = DocumentParameters()
params["content"] = language_data
api.setCustomHeaders("X-RosetteAPI-App", "python-app")
return api.language(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
entities_linked_text_data = "Last month director Paul Feig announced the movie will have an all-star female cast including Kristen Wiig, Melissa McCarthy, Leslie Jones and Kate McKinnon."
params = DocumentParameters()
params["content"] = entities_linked_text_data
params["genre"] = "social-media"
# This syntax is deprecated, call api.entities(params)
return api.entities(params, True)
def run(alt_url='https://api.rosette.com/rest/v1/', sentence = "Default Sentence"):
api = API(user_key=API_KEYS.ROSETTE_API_KEY, service_url=alt_url)
params = DocumentParameters()
params["content"] = sentence
try:
return api.categories(params)
except RosetteException as exception:
print(exception)
def call_api(self, content):
params = DocumentParameters()
params["content"] = content[0:49999] # truncate to first 50000 chars
res = {}
try:
res = self.client.entities(params)
except RosetteException as exception:
print(exception)
res = {"rosette_exception": str(exception)}
return json.dumps(res, sort_keys=True, indent=4)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
categories_url_data = "http://www.onlocationvacations.com/2015/03/05/the-new-ghostbusters-movie-begins-filming-in-boston-in-june/"
url = categories_url_data
# Create an API instance
api = API(user_key=key, service_url=altUrl)
params = DocumentParameters()
# Use a URL to input data instead of a string
params["contentUri"] = url
return api.categories(params)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create default file to read from
f = tempfile.NamedTemporaryFile(suffix=".html")
message = "<html><head><title>New Ghostbusters Film</title></head><body><p>Original Ghostbuster Dan Aykroyd, who also co-wrote the 1984 Ghostbusters film, couldn’t be more pleased with the new all-female Ghostbusters cast, telling The Hollywood Reporter, “The Aykroyd family is delighted by this inheritance of the Ghostbusters torch by these most magnificent women in comedy.”</p></body></html>"
f.write(message)
f.seek(0)
# Create an API instance
api = API(user_key=key, service_url=altUrl)
params = DocumentParameters()
# Use an HTML file to load data instead of a string
params.load_document_file(f.name)
result = api.sentiment(params)
# Clean up the file
f.close()
return result
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_han_readings_data = "北京大学生物系主任办公室内部会议"
params = DocumentParameters()
params["content"] = morphology_han_readings_data
try:
return api.morphology(params, api.morphology_output['HAN_READINGS'])
except RosetteException as e:
print(e)
def run(key, alt_url='https://api.rosette.com/rest/v1/'):
""" Run the example """
# Create an API instance
api = API(user_key=key, service_url=alt_url)
embeddings_data = "Cambridge, Massachusetts"
params = DocumentParameters()
params["content"] = embeddings_data
try:
return api.text_embedding(params)
except RosetteException as exception:
print(exception)
def run(key, alt_url='https://api.rosette.com/rest/v1/'):
""" Run the example """
syntax_dependencies_data = "Yoshinori Ohsumi, a Japanese cell biologist, was awarded the Nobel Prize in Physiology or Medicine on Monday."
params = DocumentParameters()
params["content"] = syntax_dependencies_data
# Create an API instance
api = API(user_key=key, service_url=alt_url)
try:
return api.syntax_dependencies(params)
except RosetteException as exception:
print(exception)
def run(key, alt_url='https://api.rosette.com/rest/v1/'):
""" Run the example """
# Create an API instance
api = API(user_key=key, service_url=alt_url)
relationships_text_data = "FLIR Systems is headquartered in Oregon and produces thermal imaging, night vision, and infrared cameras and sensor systems. According to the SEC’s order instituting a settled administrative proceeding, FLIR entered into a multi-million dollar contract to provide thermal binoculars to the Saudi government in November 2008. Timms and Ramahi were the primary sales employees responsible for the contract, and also were involved in negotiations to sell FLIR’s security cameras to the same government officials. At the time, Timms was the head of FLIR’s Middle East office in Dubai."
params = DocumentParameters()
params["content"] = relationships_text_data
try:
return api.relationships(params)
except RosetteException as exception:
print(exception)
def run(key, altUrl='https://api.rosette.com/rest/v1/'):
# Create an API instance
api = API(user_key=key, service_url=altUrl)
morphology_parts_of_speech_data = "The fact is that the geese just went back to get a rest and I'm not banking on their return soon"
params = DocumentParameters()
params["content"] = morphology_parts_of_speech_data
try:
return api.morphology(params, MorphologyOutput.PARTS_OF_SPEECH)
except RosetteException as e:
print(e)
<p>This is a simple sample HTML file to demonstrate the option of loading data from a file.</p>
</body>
</html>"""
f.write(message)
f.seek(0)
# Collect arguments
parser = argparse.ArgumentParser(description="Get the sentiment of the text in a local file")
parser.add_argument("--key", required=True, help="Rosette API key")
parser.add_argument("--service_url", nargs="?", help="Optional user service URL")
parser.add_argument("--file", nargs="?", default=f.name, help="Optional input file for data")
args = parser.parse_args()
# Create an API instance
if args.service_url:
api = API(service_url=args.service_url, user_key=args.key)
else:
api = API(user_key=args.key)
params = DocumentParameters()
# Use an HTML file to load data instead of a string
params.load_document_file(args.file)
result = api.sentiment(params)
# Clean up the file
f.close()
pprint.pprint(result)