class LanguageResponseTest(unittest.TestCase):
outputOK = {"status": {"code": "0", "msg": "OK", "credits": "1", "remaining_credits": "32033"}, "language_list":[{"language": "en", "relevance": 100, "name": "English", "iso639-3": "eng", "iso639-2": "en"}]}
outputOK = json.dumps(outputOK)
response = meaningcloud.LanguageResponse(outputOK)
outputEmpty = {"status": {"code": "0", "msg": "OK", "credits": "1", "remaining_credits": "32033"}, 'language_list': []}
empty_response = meaningcloud.LanguageResponse(json.dumps(outputEmpty))
def testConstruct(self):
self.assertIsNotNone(self.response.getResponse())
def testConstructWithWrongJson(self):
outputWrong = 'malformed json'
with self.assertRaises(json.JSONDecodeError):
meaningcloud.LanguageResponse(outputWrong)
def testConstructWithEmptyParam(self):
with self.assertRaises(Exception):
meaningcloud.LanguageResponse('')
def testGetLanguages(self):
self.assertIsNotNone(self.response.getLanguages())
self.assertTrue(isinstance(self.response.getLanguages(), list))
def testGetNonexistentLanguages(self):
self.assertEqual(len(self.empty_response.getLanguages()), 0)
def testGetLanguageCode(self):
languages = self.response.getLanguages()
language = languages[0] if((len(languages) > 0) and (languages[0] is not None)) else []
self.assertIsNotNone(self.response.getLanguageCode(language))
def testGetLanguageCodeWithEmptyInput(self):
self.assertEqual(self.response.getLanguageCode([]), "")
def testGetLanguageName(self):
languages = self.response.getLanguages()
language = languages[0] if ((len(languages) > 0) and (languages[0] is not None)) else []
self.assertIsNotNone(self.response.getLanguageName(language))
def testGetLanguageNameWithEmptyInput(self):
self.assertEqual(self.response.getLanguageName([]), "")
def detectLanguage(text, get_name=False):
language = ''
# We are going to make a request to the Language Identification API
print("\tDetecting language...")
lang_response = meaningcloud.LanguageResponse(meaningcloud.LanguageRequest(license_key, txt=text).sendReq())
if lang_response.isSuccessful():
langs = lang_response.getLanguages()
if langs:
language = lang_response.getLanguageCode(langs[0]) if not get_name else lang_response.getLanguageName(langs[0])
else:
print("\tOops! Request to detect language was not succesful: (" + lang_response.getStatusCode() + ') ' + lang_response.getStatusMsg())
return language
def analyzeText(text):
global index_count
print("Identifying language for text #%s" % str(index_count))
# this is where we are going to store our results
language_code = ""
language_name = ""
try:
# We are going to make a request to the Language Identification API
request = meaningcloud.LanguageRequest(license_key, txt=text, server=server)
setRequestSource(request)
response = meaningcloud.LanguageResponse(request.sendReq())
if response.isSuccessful():
lang = response.getFirstLanguage()
if lang:
language_code = response.getLanguageCode(lang)
language_name = response.getLanguageName(lang)
else:
if isBlockingErrorType(response.getStatusCode()):
raise ValueError(
"Something went wrong in the MeaningCloud request!: ("
+ response.getStatusCode()
+ ") "
+ response.getStatusMsg()
)
else:
print(
"Oops! The request to Language Identification for text #"
+ str(index_count)
+ " was not succesful: ("
+ response.getStatusCode()
+ ") "
+ response.getStatusMsg()
)
language_code = (
"ERROR ("
+ response.getStatusCode()
+ "): "
+ response.getStatusMsg()
)
except ValueError as e:
raise ValueError(str(e))
index_count += 1
return pd.Series([language_code, language_name])
def testConstructWithEmptyParam(self):
with self.assertRaises(Exception):
meaningcloud.LanguageResponse('')
def testConstructWithWrongJson(self):
outputWrong = 'malformed json'
with self.assertRaises(json.JSONDecodeError):
meaningcloud.LanguageResponse(outputWrong)
# CLASS API CALL
# class_response = meaningcloud.ClassResponse(
# meaningcloud.ClassRequest(license_key, txt=text, model=model).sendReq())
# SENTIMENT API CALL
# sentiment_response = meaningcloud.SentimentResponse(
# meaningcloud.SentimentRequest(license_key, lang='en', txt=text, txtf='plain').sendReq())
# GENERIC API CALL
# generic = meaningcloud.Request(url="url_of_specific_API",key=key)
# generic.addParam('parameter','value')
# generic_result = generic.sendRequest()
# generic_response = meaningcloud.Response(generic_result)
# We are going to make a request to the Language Identification API
lang_response = meaningcloud.LanguageResponse(meaningcloud.LanguageRequest(license_key, txt=text).sendReq())
# If there are no errors in the request, we will use the language detected to make a request to Sentiment and Topics
if lang_response.isSuccessful():
print("\nThe request to 'Language Identification' finished successfully!\n")
languages = lang_response.getLanguages()
if languages:
language = lang_response.getLanguageCode(languages[0])
print("\tLanguage detected: " + lang_response.getLanguageName(languages[0]) + ' (' + language + ")\n")
else:
print("\tNo language detected!\n")
# We are going to make a request to the Lemmatization, PoS and Parsing API
parser_response = meaningcloud.ParserResponse(
meaningcloud.ParserRequest(license_key, txt=text, lang='en').sendReq())