def analyse_sentimentwt(df, term):
authenticator = IAMAuthenticator('api-key')
language_translator = LanguageTranslatorV3(version='date',
authenticator=authenticator)
language_translator.set_service_url('url')
df[term].replace(['[deleted]', '[removed]'], [1.1, 1.1], inplace=True)
f_list = df[term].to_list()
for l in f_list:
l = l.encode('unicode-escape').decode('utf-8')
pol = list()
for l in f_list:
print(l, "\n")
if (l != 1.1):
language = language_translator.identify(l).get_result()
n = language['languages']
m = n[0]['language']
if (m == 'hi'):
translation = language_translator.translate(
text=l, model_id='hi-en').get_result()
p = translation['translations']
k = p[0]['translation']
l = k
analysis = TextBlob(l).sentiment
t = analysis.polarity
pol.append(t)
else:
pol.append(1.1)
df['sentiment'] = pol
return df
def translate_sentence(recognized_sentence):
apikey_lt = "API key credentials of IBM watson Language Translator Service"
url_lt = "url credentials of IBM watson Language Translator Service"
version_lt = "2018-05-01"
authenticator = IAMAuthenticator(apikey_lt)
language_translator = LanguageTranslatorV3(version=version_lt,
authenticator=authenticator)
language_translator.set_service_url(url_lt)
json_normalize(
language_translator.list_identifiable_languages().get_result(),
"languages")
translation_response = language_translator.translate(text=recognized_text,
model_id="en-es")
#print(translation_response)
translation = translation_response.get_result()
#print(translation)
spanish_translation = translation["translations"][0]["translation"]
return (spanish_translation)
def getTranslatorText(convText):
global language_identify
laguage_kwargs = {
'version': '2018-05-01',
'username': tranlatorUser,
'password': tranlatorPassword,
'iam_apikey': tranlatorIAMKey,
'url': tranlatorUrl
}
language_translator = LanguageTranslatorV3(**laguage_kwargs)
if convText!=None and convText != '' :
language = language_translator.identify(convText).get_result()
language_identify = language['languages'][0]['language']
print(language['languages'][0]['language'])
if language_identify != 'ja' and language_identify !='zh' and language_identify !='zh-TW':
language_identify = 'en'
translation = language_translator.translate(text=convText,model_id='en'+'-ja').get_result()
# translation = language_translator.translate(text=convText,model_id=language_identify+'-ja').get_result()
convText = translation['translations'][0]['translation']
print('翻訳後： '+convText)
return convText
def get_client():
print("Using IBM Watson for translation client")
error = []
try:
# reads the API key and url from the IBM json
with open(os.path.join(REPO_PATH, ".ibmkeyfile.json")) as f:
results = json.load(f)
api_key = results["api_key"]
api_url = results["api_url"]
# instantiates instance of IBM API with IAM authentication
authenticator = IAMAuthenticator(api_key)
language_translator = LanguageTranslatorV3(
version='2018-05-01', # this is the current version
authenticator=authenticator)
language_translator.set_service_url(api_url)
return language_translator
except IBMException as e:
error.append(str(e))
except Exception as e:
error.append(str(e))
print("\n".join(error))
return None
def translate_to_english(text):
# detect text
language_translator = LanguageTranslatorV3(version='2018-05-01', iam_apikey=language_translator_api_key, url='https://gateway.watsonplatform.net/language-translator/api')
language = language_translator.identify(text).get_result()['languages'][0]['language']
translation = language_translator.translate(text=text, model_id=language+'-en').get_result()
return translation['translations'][0]['translation']
def english_to_german(en_text):
"""
Translate text from English to German using IBM Watson API.
:param en_text: English string to translate.
:return: String of text in German.
"""
# Initialize the IBM Watson API
if LANGUAGE_API_KEY == "--Login to IBM Watson for Key--":
print("[ERROR] Please fill in the IBM Watson API Key.")
else:
authenticator = IAMAuthenticator(LANGUAGE_API_KEY)
language_translator = LanguageTranslatorV3(version=VERSION_LT,
authenticator=authenticator)
language_translator.set_service_url(LANGUAGE_API_URL)
# Prevent user from trying to translate null values.
if en_text != "":
# Translate text and output a formatted string
translator_response = language_translator.translate(text=en_text,
model_id='en-de')
de_translation = translator_response.get_result(
)['translations'][0]['translation']
else:
print("[ERROR] translator/english_to_german() - Cannot translate a "
"NULL string.")
de_translation = "NULL"
return de_translation
def __init__(self):
API_KEY = 'pU-g-4CPjauoZBpVDEC58QMPfXxXl8R06EnmurtIb9QX'
authenticator = IAMAuthenticator(API_KEY)
self.language_translator = LanguageTranslatorV3(
version='2018-05-01', authenticator=authenticator)
self.language_translator.set_service_url(
'https://gateway.watsonplatform.net/language-translator/api')
def get_translations(df, nlu_api_key, lt_base_url):
""" Translate text from a Pandas DataFrame's 'text column to English.
:param DataFrame df: DataFrame containing an 'id', 'text', and 'language' column
:param str subscription_key: MS Azure subscription key
:param str text_analytics_base_url: endpoint for the Text Analytics REST API
:return: Values of the outputs to the API calls (list of tuples)
:rtype: list
"""
language_translator = LanguageTranslatorV3(version='2018-05-01',
iam_apikey=nlu_api_key,
url=lt_base_url)
value_list = []
progress_bar = tqdm(df.itertuples(), total=df.shape[0])
progress_bar.set_description('Updating emotions')
for row in progress_bar:
try:
response = language_translator.translate(
text=row.text, model_id=f'{row.language}-en').get_result()
values = (response['translations'][0]['translation'], row.id)
value_list.append(values)
except:
values = ('N/A', row.id)
value_list.append(values)
return value_list
def __init__(self, url, api_key):
self.url = url
self.api_key = api_key
authenticator = IAMAuthenticator(api_key)
self.language_translator = LanguageTranslatorV3(
version='2018-05-01', authenticator=authenticator)
self.language_translator.set_service_url(url)
def Translator(x):
authenticator = IAMAuthenticator('Xxx')
language_translator = LanguageTranslatorV3(version='2018-05-01',authenticator=authenticator)
language_translator.set_service_url('https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances/ad0baccc-1587-4c3c-aeba-9bdd06e96161')
translation = language_translator.translate(text=x,model_id='en-es').get_result()
_answer_ = json.dumps(translation, indent=2)["translations"][0]["translation"]
return print('The translation:', _answer_))
def init_watson_translator():
authenticator = IAMAuthenticator(settings.WATSON_IAM_KEY)
language_translator = LanguageTranslatorV3(version=settings.WATSON_VERSION,
authenticator=authenticator)
language_translator.set_service_url(settings.WATSON_SERVICE_URL)
return language_translator
def res():
print ('inicia')
audio = pyaudio.PyAudio()
stream = audio.open(format = pyaudio.paInt16, channels = 2, rate = 44100, frames_per_buffer = 1024, input = True)
print('Inicia grabación')
frames = []
tiempo = 5 #segundos
for i in range(0, int(44100/1024*tiempo)):
tmp = stream.read(1024)
frames.append(tmp)
print('Acaba la captura')
stream.stop_stream()
stream.close()
waveFile = wave.open('graba.wav','wb')
waveFile.setnchannels(2)
waveFile.setframerate(44100)
waveFile.setsampwidth(audio.get_sample_size(pyaudio.paInt16))
waveFile.writeframes(b''.join(frames))
waveFile.close()
servicio = SpeechToTextV1(iam_apikey ='id de watson')
with open('graba.wav','rb') as fichero:
res = json.dumps(servicio.recognize(audio = fichero,timestamps = True,model = 'es-ES_NarrowbandModel', word_confidence = True).get_result(),sort_keys=True ,indent = 2)
resultado=json.loads(res)
res=resultado["results"]
res=res[0]
res=res["alternatives"]
res=res[0]
res=res["transcript"]
print(res)
audio= res
#----------------------------------------traduccion----------------------------------------------
language_translator = LanguageTranslatorV3(
version='2018-05-01',
iam_apikey='id de watson',
url='https://gateway.watsonplatform.net/language-translator/api')
translation = language_translator.translate(
text=res, model_id='es-en').get_result()
traduccion=json.dumps(translation, indent=2, ensure_ascii=False)
#print(traduccion)
traduccion=json.loads(traduccion)
traduccion= traduccion["translations"]
traduccion= traduccion[0]
traduccion= traduccion["translation"]
print(traduccion)
traduccion1=traduccion
##-----------------------------------------------analizador
tone_analyzer = ToneAnalyzerV3(version = '2017-09-21',iam_apikey = 'id de watson, url = 'https://gateway.watsonplatform.net/tone-analyzer/api' )
def translate_text(text, model):
service = LanguageTranslatorV3(
version='2018-05-01',
authenticator=IAMAuthenticator(
'twXIJP-10FISqL-tH1DJ_E3nmr26j_1UDhyZH-ExzpMT'))
response = service.translate(text, model_id=model).get_result()
result = py_.get(response, 'translations.0.translation')
return result
def Translator(x,y):
authenticator = IAMAuthenticator('XxO7r8R6IIpppV1xL1-9BsrkJwYi60MU9MLQcAKvwo1y')
language_translator = LanguageTranslatorV3(version='2018-05-01',authenticator=authenticator)
language_translator.set_service_url('https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances/ad0baccc-1587-4c3c-aeba-9bdd06e96161')
if y == 0:
translation = language_translator.translate(text=x,model_id='en-fr').get_result()
elif y == 1:
translation = language_translator.translate(text=x,model_id='en-es').get_result()
return print(translation['translations'][0]['translation'])
def translate(text, source_language, dest_language):
url = current_app.config['IBMAPI_URL']
authenticator = IAMAuthenticator(current_app.config['IBMAPI_KEY'])
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(url)
r = language_translator.translate(text=text,
model_id=source_language + '-' +
dest_language).get_result()
r = r['translations'][0]['translation']
return r
def translate(text, language):
modelid = 'en-' + language
authenticator = IAMAuthenticator('hidden')
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(
'https://api.eu-de.language-translator.watson.cloud.ibm.com/instances/hidden'
)
translationibm = language_translator.translate(
text=piece, model_id=modelid).get_result()
return translationibm
def translate_content(self) -> "IBM_NLP":
authenticator = IAMAuthenticator(os.getenv("IBM_LAN_API"))
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(os.getenv("IBM_LAN_URL"))
translation = language_translator.translate(
text=self.text, model_id=f'{self.another_lan}-en').get_result()
self.text = translation['translations'][0]['translation']
def spanishTranslator(): # translation function for spanish text
authenticator = IAMAuthenticator('<authentical information')
language_translator = LanguageTranslatorV3(version='2020-01-16',
authenticator=authenticator)
language_translator.set_service_url('url information')
translation = language_translator.translate(
text=interSpan1, model_id='es-en').get_result()
print(translation)
reply = jibu + ',' + studentNumber + ',' + studentName4 + ':' + translation
registrationReply = bytes(reply, 'ascii')
microcontroller_2.write(registrationReply)
def englishtogerman(word):
"""This class does english to german translation"""
url_lt='https://api.us-south.language-translator.watson.cloud.ibm.com/instances/dfb4e059-a2b5-470b-9ac4-f4628099cf0a'
apikey_lt='5W4TiN2vz1utmA3YgN0-m9qv7TgzznYioDwTXPc4g_-7'
version_lt='2018-05-01'
authenticator = IAMAuthenticator(apikey_lt)
language_translator = LanguageTranslatorV3(version=version_lt,authenticator=authenticator)
language_translator.set_service_url(url_lt)
lt = language_translator
translation = lt.translate(text=word, model_id="en-de").get_result()
return translation['translations'][0]['translation']
def convert_en_to_ar(text):
authenticator = IAMAuthenticator(ibm_api_key)
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(ibm_url)
translation = language_translator.translate(text=text,
model_id='en-ar').get_result()
ar_translation = translation['translations'][0]['translation']
return ar_translation
def spanishLanguageTranslator(
): # translation function for incoming english language to spanish
authenticator = IAMAuthenticator('authentication information')
language_translator = LanguageTranslatorV3(version='2020-01-16',
authenticator=authenticator)
language_translator.set_service_url('https://url information')
translation = language_translator.translate(
text=translationText, model_id='en-es').get_result()
print(translation)
reply = jibu + ',' + studentNumber + ',' + studentNumber + ':' + translation
registrationReply = bytes(reply, 'ascii')
microcontroller_2.write(registrationReply)
def Translator(lang, data):
#mymodel=lang1[:2]+'-'+lang[:2]
mymodel = 'en-' + lang[:2]
#print(mymodel)
authenticator = IAMAuthenticator(IAMAuth2)
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(service_url2)
translation = language_translator.translate(text=data,
model_id=mymodel).get_result()
print(translation['translations'][0]['translation'])
return translation['translations'][0]['translation']
def initServices(app):
# Setup MQTT
app.config['MQTT_BROKER_URL'] = 'test.mosquitto.org'
app.config['MQTT_BROKER_PORT'] = 1883
mqtt = Mqtt(app)
app.config['MQTT_CLIENT'] = mqtt
# Setup IBM Watson
load_dotenv()
authenticator = IAMAuthenticator(os.getenv("STT_API_KEY"))
service = SpeechToTextV1(authenticator=authenticator)
service.set_service_url(os.getenv("STT_URL"))
app.config['SPEECH_TO_TEXT'] = service
authenticator_translate = IAMAuthenticator(os.getenv("TRANSLATE_API_KEY"))
language_translator = LanguageTranslatorV3(
version='2018-05-01', authenticator=authenticator_translate)
language_translator.set_service_url(os.getenv("TRANSLATE_URL"))
app.config['LANGUAGE_TRANSLATOR'] = language_translator
# IBM COS
app.config['COS_ENDPOINT'] = os.getenv("COS_ENDPOINT")
if not app.config['COS_ENDPOINT'].startswith(
'http') or not app.config['COS_ENDPOINT'].startswith('https'):
app.config['COS_ENDPOINT'] = 'https://' + app.config['COS_ENDPOINT']
cos = ibm_boto3.resource(
"s3",
ibm_api_key_id=os.getenv("COS_API_KEY"),
ibm_service_instance_id=os.getenv("COS_IAM_ROLE_CRN"),
ibm_auth_endpoint='https://iam.cloud.ibm.com/identity/token',
config=Config(signature_version="oauth"),
endpoint_url=app.config['COS_ENDPOINT'])
app.config['COS'] = cos
app.config['COS_BUCKET_NAME'] = os.getenv("COS_BUCKET_NAME")
# Setup config
# app.config['BASE'] = os.path.join(os.path.dirname(os.getcwd()),'cfc-covid-19-video-transcriber-starter')
app.config['BASE'] = os.path.join(os.path.dirname(os.getcwd()), '/app')
app.config['BASE'] = os.path.join(app.config['BASE'], 'server')
app.config['UPLOAD_FOLDER'] = os.path.join(app.config['BASE'],
'video_uploads')
app.config['AUDIO_FOLDER'] = os.path.join(app.config['BASE'],
'audio_extractions')
app.config['OUTPUT_FOLDER'] = os.path.join(app.config['BASE'],
'output_transcripts')
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
os.makedirs(app.config['AUDIO_FOLDER'], exist_ok=True)
os.makedirs(app.config['OUTPUT_FOLDER'], exist_ok=True)
return
def getTranslatorToEnlish(text):
laguage_kwargs = {
'version': '2018-05-01',
'username': tranlatorUser,
'password': tranlatorPassword,
'iam_apikey': tranlatorIAMKey,
'url': tranlatorUrl
}
language_translator = LanguageTranslatorV3(**laguage_kwargs)
translation = language_translator.translate(text=text,model_id='ja-en').get_result()
return translation
def translate(text, language):
""" Reçoit un texte et un string décrivant le sens de traduction voulu
Utilise l'API d'IBM Watson Language Translator et renvoie le texte traduit
"""
language_translator = LanguageTranslatorV3(
version='2018-05-01',
iam_apikey=APIKEY,
url='https://gateway-lon.watsonplatform.net/language-translator/api')
translation = language_translator.translate(text, language).get_result()
return json.dumps(translation['translations'][0]['translation'], \
ensure_ascii=False).replace("\"", "")
def language_translator(input_text,target_language):
api_key_translator = '{api-key}'
url_translator = "{api-key}"
authenticator = IAMAuthenticator(api_key_translator)
language_translator = LanguageTranslatorV3(
version='2020-06-03',
authenticator=authenticator)
language_translator.set_service_url(url_translator)
language_translator.set_disable_ssl_verification(True)
translation = language_translator.translate(
text=input_text , target = target_language).get_result()
results = json.dumps(translation, indent=2, ensure_ascii=False)
return results
def languange_translator(in_file):
"""
Translate text from English to Spanish
"""
recognized_text = speech_to_text(in_file)
authenticator_lt = IAMAuthenticator(os.environ.get('LT_KEY'))
language_translator = LanguageTranslatorV3(
version=os.environ.get('VERSION'), authenticator=authenticator_lt)
language_translator.set_service_url(os.environ.get('LT_URL'))
translated_response = language_translator.translate(text=recognized_text,
model_id='en-es')
translation = translated_response.get_result()
final_trans = translation['translations'][0]['translation']
return final_trans
def _get_translator(self):
"""
Uses provided value in the config value to authenticate to Watson Translate API
:return: LanguageTranslatorV3
"""
authenticator = IAMAuthenticator(
self.options["fn_watson_translate_api"])
language_translator = LanguageTranslatorV3(
version=self.options["fn_watson_translate_version"],
authenticator=authenticator)
language_translator.set_service_url(
self.options["fn_watson_translate_url"])
return language_translator
def translator(text, lang):
"""
authentication with the ibm language translator instance/function returns a dictionary with
the translated text
"""
authenticator = IAMAuthenticator('key_aquired_by_ibm')
language_translator = LanguageTranslatorV3(version='2018-05-01',
authenticator=authenticator)
language_translator.set_service_url(
'https://api.us-south.language-translator.watson.cloud.ibm.com/instances/2598d376-0b24-4053-a279-aeabd167e5a8'
)
translation = language_translator.translate(text=text,
model_id=lang).get_result()
return translation
def data_from_CSV():
conn = establish_DB_connection_SQL()
df = pd.read_csv(sys.argv[1], keep_default_na=False)
tweets = df.set_index('status_id', drop=False)
for index, row in tweets.iterrows():
phone_no = ''
hashtag = []
text = str(row['text'])
if str(detect_langs(text)[0])[0:2] == 'hi' and text != 'nan':
text1 = text
authenticator = IAMAuthenticator(
'worUzb_Eb5emCaIs0oL7sR86Fb2LeTJGOk1EN1Q-4Cni')
language_translator = LanguageTranslatorV3(
version='2018-05-01', authenticator=authenticator)
language_translator.set_service_url(
'https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances/cdafbc7e-b59a-40f8-818f-1914f02063cc'
)
translation = language_translator.translate(
text=text1, model_id='hi-en').get_result()
output = json.loads(
json.dumps(translation, indent=2, ensure_ascii=False))
text = output['translations'][0]['translation']
if str(detect_langs(text)[0])[0:2] == 'en' and text != 'nan':
text = data_cleaning(text)
words = text.split()
words = set(words)
words = list(words)
for w in words:
if re.match(
'^((\+){0,1}91(\s){0,1}(\-){0,1}(\s){0,1}){0,1}0{0,1}[1-9]{1}[0-9]{9}$',
w):
phone_no = w[-10:]
if w.startswith('#'):
hashtag.append(w)
request_type = processML(text)
if request_type != '':
name = str(row['screen_name'])
if name == '': name = None
if text == '': text = None
if phone_no == '': phone_no = 9900990099
latitude = 9.9252
longitude = 78.1198
updateDB_SQL(row['screen_name'], text, latitude, longitude,
phone_no, request_type, conn)
disconnect_DB_SQL()
