class YandexTranslateTest(unittest.TestCase):
def setUp(self):
self.translate = YandexTranslate(YANDEX_API_KEY)
def test_langs(self):
languages = self.translate.langs
self.assertEqual(languages, set(
[
u"el", u"en", u"ca", u"it",
u"hy", u"cs", u"et", u"az",
u"es", u"ru", u"nl", u"pt",
u"no", u"tr", u"lv", u"lt",
u"ro", u"pl", u"be", u"fr",
u"bg", u"hr", u"de", u"da",
u"fi", u"hu", u"sr", u"sq",
u"sv", u"mk", u"sk", u"uk",
u"sl"
]
))
def test_lang_detection(self):
language = self.translate.detect("Je m'appele Malika")
self.assertEqual(language, 'fr')
def test_translation(self):
result = self.translate.translate(u"Hello", 'en-es')
self.assertEqual(result["text"][0], u"Hola")
self.assertEqual(result["code"], 200)
def test_opposite_translation(self):
result = self.translate.translate(u"Hola", 'es-en')
self.assertEqual(result["text"][0], u"Hello")
self.assertEqual(result["code"], 200)
def translate(text,source,dest):
# print("\n\n {0} {1} {2} \n\n".format(text,source,dest))
translate = YandexTranslate('trnsl.1.1.20190515T114153Z.33301c8ad79f95bd.69a1158dfac270a48213caaf9b6102a3115b8fe1')
if source =='Eng':
lang_source='en'
if source =='Ru':
lang_source='ru'
if dest =='Eng':
lang_dest='en'
if dest =='Ru':
lang_dest='ru'
if source == 'Fra':
lang_source='fr'
if dest =='Fra':
lang_dest='fr'
try:
check = translate.detect(text)
except:
print("Check Exception on text: {}".format(text))
return text
# print("\n\n check: {0} \n\n".format(check))
if not check.find(lang_dest):
empty = lang_dest + '-' + lang_source
#print("\n\n empty: {0} \n\n".format(empty))
rez=translate.translate(text, empty)
s = rez['text'][0].decode('utf8')
# print(u"\n\n rez: {0} \n\n".format(s))
return s
return text
def test_blocked_key(self):
translate = YandexTranslate(
"trnsl.1.1.20130723T112255Z.cfcd2b1ebae9f"
"ff1.86f3d1de3621e69b8c432fcdd6803bb87ef0e963")
with self.assertRaises(YandexTranslateException,
msg="ERR_KEY_BLOCKED"):
languages = translate.detect("Hello!")
async def ytranslate(self, ctx, language: str, *, text: str):
"""Translate text via yandex
Language may be just "ru" (target language to translate)
or "en-ru" (original text's language - target language)"""
text = chat.escape(text, formatting=True)
apikeys = await self.bot.db.api_tokens.get_raw("yandex", default={"translate": None})
try:
translate = YandexTranslate(apikeys["translate"])
response = translate.translate(text, language)
except YandexTranslateException as e:
if str(e) == "ERR_LANG_NOT_SUPPORTED":
await ctx.send(chat.error("An error has been occurred: Language {} is not supported"
.format(chat.inline(language))))
elif str(e) == "ERR_TEXT_TOO_LONG":
# Discord will return BAD REQUEST (400) sooner than this happen, but whatever...
await ctx.send(chat.error("An error has been occurred: Text that you provided is too big to "
"translate"))
elif str(e) == "ERR_KEY_INVALID":
await ctx.send(chat.error("This command requires Yandex.Translate API key\n"
"You can set it via {}ytapikey".format(ctx.prefix)))
elif str(e) == "ERR_KEY_BLOCKED":
await ctx.send(chat.error("API key is blocked. You need to get new api key or unlock current."))
elif str(e) == "ERR_DAILY_REQ_LIMIT_EXCEEDED":
await ctx.send(chat.error("Daily requests limit reached. Try again later."))
elif str(e) == "ERR_DAILY_CHAR_LIMIT_EXCEEDED":
await ctx.send(chat.error("Daily char limit is exceeded. Try again later."))
elif str(e) == "ERR_UNPROCESSABLE_TEXT":
await ctx.send(chat.error("An error has been occurred: Text is unprocessable by translation server"))
elif str(e) == "ERR_SERVICE_NOT_AVAIBLE":
await ctx.send(chat.error("An error has been occurred: Service Unavailable. Try again later"))
else:
await ctx.send(chat.error("An error has been occurred: {}".format(e)))
return
input_lang = None
output_lang = None
if len(language) == 2:
try:
input_lang = translate.detect(text=text)
except YandexTranslateException as e:
if str(e) == "ERR_LANG_NOT_SUPPORTED":
await ctx.send(chat.error("This language is not supported"))
else:
await ctx.send(chat.error("Unable to detect language: {}".format(e)))
return
output_lang = language
elif len(language) == 5:
input_lang = language[:2]
output_lang = language[3:]
if response["code"] == 200:
await ctx.send("**[{}] Input:** {}".format(input_lang.upper(), chat.box(text)))
await ctx.send("**[{}] Translation:** {}".format(output_lang.upper(), chat.box(response["text"][0])))
else:
# According to yandex.translate source code this cannot happen too, but whatever...
await ctx.send("An error has been occurred. Translation server returned code {}"
.format(chat.inline(response["code"])))
def translate(text):
'''Translates the message from one language to another'''
## Mr. Scott's secret key for Yandex API
translate = YandexTranslate('') #Yandex key
finalText, languageTo = getLanguage(text)
## detect the language of the text
language = translate.detect(finalText)
print('Translating from',language,'to',languageTo)
## translate to english
translated = 'Translate:', translate.translate(finalText, language+'-'+languageTo)
return (translated[1]['text'][0])
def translate_language(sourcetext, translationfrom, translationTo):
translate = YandexTranslate(
'trnsl.1.1.20171108T161528Z.11fd5cf559085f7e.68f45fa90a6197a56fc8353410bec46f7386e419'
)
print('Languages:', translate.langs)
print('Translate directions:', translate.directions)
print('Detect language:', translate.detect(sourcetext))
translated_text = translate.translate(
sourcetext, translationfrom + '-' + translationTo)
arr = translated_text['text']
return arr
print(arr)
class ya_translate(object):
def __init__(self):
self.translate = YandexTranslate('trnsl.1.1.20170417T120755Z.ace07b3e54a7011b.23ef0f7b86f04dff506c4b86bdb4eb547901af1b')
def get_english_words(self,eng_word):
tmp_translate_word=self.translate.translate(eng_word,"ru")
translate_word=tmp_translate_word['text'][0]
if self.translate.detect(translate_word) in 'ru':
return translate_word
else:
return
class Yanslate:
def __init__( self, key ):
self.translate = YandexTranslate( key )
def detect( self, text ):
print('Detect language:', self.translate.detect( text ))
def list( self ):
print('Languages:', self.translate.langs)
def trans( self,text, lang ):
return ('Translate:', self.translate.translate(text, lang))
async def t(arg):
'translate'
translator = YandexTranslate(config.yandex_translate_key)
# lang = translator.detect(arg)
if arg.startswith('-'):
lang, text = arg.split(None, 1)
lang = lang[1:]
else:
text = arg
lang = translator.detect(text)
if lang != 'en':
translation = translator.translate(text, '{}-en'.format(lang))['text'][0]
answer = 'translated from {}\n{}'.format(lang, translation)
return answer
else:
return "That's already English"
class Translator(object):
"""
Wrapper around the Yandex translate API package.
Provides methods for determining whether a text is english, and translating it english if not.
"""
translator = None
def __init__(self, api_key):
self.translator = YandexTranslate(api_key)
def translator(self):
"""
Returns:
YandexTranslate: the initialised YandexTranslate instance
"""
return self.translator
def is_english(self, input_text):
"""
Use the translator to determine whether the input text is English.
If it is then returns True, otherwise it returns the detected language
type.
Returns:
True if english, otherwise language string if not english.
"""
language = self.translator.detect(input_text)
if language == "en":
return True
return language
def translate(self, input_text):
"""
Translates the input text into English.
Returns:
str: The translated text
"""
return self.translator.translate(input_text, "en")
def yandex(text):
from yandex_translate import YandexTranslate
translate = YandexTranslate('<YANDEX-API-KEY>')
lang = translate.detect(text)
outtext.delete(1.0, END)
# весь текст перевести в нижний регистр и разделить по пробелам в список
# и удалить символы ! и ?
words = text.lower().translate({ord('!'): '', ord('?'): ''}).split()
# убрать повторяющиеся слова (преобразовав в кортеж) и отсортировать по алфавиту
words = sorted(set(words))
for word in words:
if lang == "en":
h = translate.translate(word, 'en-ru')
elif lang == "ru":
h = translate.translate(word, 'ru-en')
outtext.insert(END, word + " - " + str(h.get("text")) + "\n")
def translate_word(bot, update, args):
print('Пришло слово для перевода: "{}"'.format(args))
try:
# Подключаемся к Яндекс переводчику
translate = YandexTranslate(
'trnsl.1.1.20161206T204246Z.d8c8ef6d545c7ee5.3b96b277a0d9bb5f0a0060714a5b75d6fa6604b3')
# Получаем слово для перевода, телеграм нам дает список, собираем его в строку
word = ' '.join(args).lower()
# Определяем язык слова
word_lang = translate.detect(word)
# Если язык непонятный, пишем в чат что его не поддерживаем
if word_lang not in ['ru', 'en']:
bot.sendMessage(update.message.chat_id, 'Я знаю только русский и английский')
return
# Выбираем язык в какой требуется перевод
elif word_lang == 'ru':
lang = 'en'
else:
lang = 'ru'
# Переводим и на выходе получаем словарь
word_translated_dic = translate.translate(word, lang)
# Проверяем что полученный словарь содержит перевод и это строка
if word_translated_dic['text'][0] and isinstance(word_translated_dic['text'][0], str):
# Пишем в чат перевод из словара выбираем список по ключу text
bot.sendMessage(update.message.chat_id, 'Перевод: {}'.format(word_translated_dic['text'][0]))
# Иначе поднимаем ошибку с кодом 422
else:
raise YandexTranslateException(422)
# Если возникли проблемы с переводом, пишем про это
except YandexTranslateException:
bot.sendMessage(update.message.chat_id, 'Не смог перевести слово. Или слово такое, что Яндекс его перевести '
'не может, или просто недоступно API для перевода')
async def tts(arg):
'text to speech'
# print 'arg: <'+arg+'>'
# arg = arg.decode('utf-8').encode('utf-8')
# print 'arg: ', arg
if arg.strip() == 'languages':
return '\n'.join('{}: {}'.format(*i) for i in sorted(gtts.lang.tts_langs().items()))
if arg.startswith('-'):
lang, text = arg.split(None, 1)
lang = lang[1:]
else:
text = arg
translator = YandexTranslate(config.yandex_translate_key)
lang = translator.detect(text)
if not lang in gtts.lang.tts_langs():
lang = 'fi'
tmp_ogg_file_path = 'tmp/tts.ogg'
tts = gtts.gTTS(text=text, lang=lang, slow=False)
tts.save(tmp_ogg_file_path)
return gtts.lang.tts_langs().get(lang) + '\n' + text, tmp_ogg_file_path
class NLPEngine:
def __init__(self):
self.session_client = dialogflow.SessionsClient()
self.session_context = dialogflow.ContextsClient()
self.neutral_words = [
"bot",
"chatbot",
"iris",
"chat bot",
"hotel",
"no",
]
self.spanish_words = [
"oy",
"oye",
"ey",
"si"
]
self.translate = YandexTranslate('trnsl.1.1.20200215T104617Z.e985952a7'
'c20d3fc.45cea67a739d4bbe0d98177bb452'
'7b84b0857455')
def detect_language(self, text, last_lang='es', current_locale='es'):
locale = self.get_current_locale(current_locale)
if locale is None and last_lang is not None:
locale = last_lang
elif locale is None and last_lang is None:
locale = "es"
text = text.lower().strip()
if len(text.split()) == 1:
if text in self.neutral_words and last_lang is not None:
return last_lang
elif text in self.neutral_words and last_lang is None:
return locale
elif text in self.spanish_words:
return "es"
else:
try:
language = self.translate.detect(text)
if language in ['en', 'es']:
return language
elif last_lang is not None:
return last_lang
else:
return 'es'
except Exception:
return last_lang
try:
language = self.translate.detect(text)
if language in ['en', 'es']:
return language
elif last_lang is not None:
return last_lang
else:
return 'es'
except Exception:
return last_lang
@staticmethod
def get_current_locale(locale):
if locale.startswith("en"):
return "en"
elif locale.startswith("es"):
return "es"
else:
return None
def predict(self, user_id, message, last_lang='es', current_locale='es'):
language = self.detect_language(message, last_lang, current_locale)
intent = self.detect_intent_texts(
user_id=user_id,
text=message,
language_code= language
)
return intent
def detect_intent_texts(self, user_id, text, language_code):
"""Returns the result of detect intent with texts as inputs.
Using the same `user_id` between requests allows continuation
of the conversation."""
LOGGER.info(user_id)
LOGGER.info(language_code)
LOGGER.info(text)
session = self.session_client.session_path(DIALOGFLOW_PROJECT_ID, user_id)
context = self.session_context.session_path(DIALOGFLOW_PROJECT_ID, user_id)
text_input = dialogflow.types.TextInput(
text=text, language_code=language_code)
query_input = dialogflow.types.QueryInput(text=text_input)
response = self.session_client.detect_intent(
session=session, query_input=query_input)
intent = response.query_result.intent.display_name
if intent.endswith("- no - no") or intent.endswith(".question - yes")\
or intent.endswith(".question - no") or intent.endswith(
".hotel.cancel - yes") or\
intent.endswith(".hotel.cancel - no"):
LOGGER.info("Context Clear")
self.session_context.delete_all_contexts(context)
return intent, language_code
def test_invalid_key(self):
with self.assertRaises(YandexTranslateException, msg="ERR_KEY_INVALID"):
translate = YandexTranslate("my-invalid-key")
language = translate.detect("Hello!")
from yandex_translate import YandexTranslate
import language_codes
if __name__ == "__main__":
translate = YandexTranslate(
'trnsl.1.1.20160421T051442Z.3f43d13c5d30c594.bf3c396e87421e06cac7eab7b3771b3bf20af85c'
)
print ":speak: What do you want to translate?"
print ":listen:"
message = raw_input()
print "Translating {}".format(message)
language = translate.detect(message)
# translate from detected language to english
print ":speak:You are speaking {}".format(
language_codes.languages[language])
translation = translate.translate(message, '{}-en'.format(language))
print translation
print ":speak:The english translation is {}".format(translation["text"][0])
class Yandex(BaseService):
def __init__(self, api_key):
self._api_key = api_key
self._service = YandexTranslate(self._api_key)
self._directions = self._directions()
def translate_cascade(self, initial_language,
cascade_steps, text):
""" 1. Check for the text if the service thinks it is the same language as the user has provided
2. Check if the services thinks steps are legit and there is no step that cannot be done
3. Translate cascadingly
:param initial_language: two letter string of the language user needs to start with
:param cascade_steps: user provided steps (usually excluding the initial language)
:param text: the text user wants to translate cascadingly
:return: a tuple of all translations and the final translation in the original language
"""
logging.debug(initial_language + " - " + text)
cascade_steps = self.steps_to_execute(initial_language, cascade_steps)
if not self.check_language(initial_language, text):
raise YandexTranslateException(501)
if not self.check_cascade_steps(initial_language, cascade_steps):
raise YandexTranslateException(501)
results = {}
for lang in cascade_steps[1:]:
try:
results[lang] = self._service.translate(text, lang).get('text', '')[0]
except YandexTranslateException:
return {}
text = results[lang]
logging.debug(lang + " - " + text)
result = results[initial_language]
return (results, result)
def get_language(self, text=""):
"""get the language detected by the service
:param text: the text user wants to translate cascadingly
:return: language detected
"""
return self._service.detect(text)
def check_language(self, initial_language, text):
"""check whether the user provided text is in the same langauge as the
initial langauge provided by the user
:param initial_language: two letter string of the language user needs to start with
:param text: the text user wants to translate cascadingly
:return: boolean whether a language is correct
"""
lang = self.get_language(text)
if lang == initial_language:
is_correct_language = True
else:
is_correct_language = False
return is_correct_language
def _directions(self):
"""Service's available translation directions
:return: list of the available translation directions (from-to)
"""
return self._service.directions
def is_translation_step_valid(self, from_lang, to_lang):
"""
If one translation step valid
:param from_lang: two letter string for lang
:param to_lang: two letter string for lang
:return: boolean if translation valid from_lang to to_lang
"""
lang_pair = from_lang + "-" + to_lang
logging.debug(lang_pair)
if lang_pair.strip() in self._directions:
valid = True
else:
valid = False
return valid
def check_cascade_steps(self, initial_language, cascade_steps):
"""check if steps provided by the user are allowed by the service
:param initial_language: two letter string of the language user needs to start with
:param cascade_steps: user provided steps (usually excluding the initial language)
:return: boolean of whether all the translation steps are doable
"""
cascade_steps = self.steps_to_execute(initial_language,
cascade_steps)
is_cascade_achievable = False
# checking a language with itself is not allowed
# the first item is the initial_language
for lang in cascade_steps[1:]:
if self.is_translation_step_valid(initial_language, lang):
is_cascade_achievable = True
initial_language = lang
else:
is_cascade_achievable = False
break
return is_cascade_achievable
vk.messages.send( #Тоже самое, но для бесед
random_id = get_random_id(),
chat_id=event.chat_id,
message='Введите фразу, которую надо перевести '
)
flag = 0 #Шаманский танец для выхода из 2-х циклов
for event in longpoll.listen():
if event.type == VkBotEventType.MESSAGE_NEW and event.from_chat:
if text.lower() == 'выход':
break
else:
message = event.obj['message']
text = message['text']
trNormal = 1 #Колхозный флаг для ошибки
try: #Исключение, о них поговорим ниже
trFrom = translate.detect(text.lower()) #Определяем язык
trResult = translate.translate(text.lower(), trFrom + '-' + trTo) #Переводим
except Exception as e: #Если что-то пошло не так
trNormal = 0 #Пинаем флаг ошибки
print("Exception:", e) #Пишем в консоль
pass
if trNormal == 1:
vk.messages.send( #Тоже самое, но для бесед
random_id = get_random_id(),
chat_id=event.chat_id,
message='Вот перевод текста \n' + str(trResult['text'])
)
flag = 1
break
import csv
from yandex_translate import YandexTranslate #make sure this is imported
# this is your api key
translate = YandexTranslate('<YandexAPIKey>')
print('Languages:', translate.langs)
# read your csv, single col to be translated
with open('file.csv', 'r') as f:
reader = csv.reader(f)
your_list = list(reader)
print('Detect language:', translate.detect(your_list))
# detects the current language
trans = translate.detect(your_list)
print(trans)
print(len(your_list))
print(your_list[1])
# loop over your list, translate from detected language to english.
counter = 0
while counter < len(your_list):
lang = translate.detect(your_list[counter]),
print('Translate:', translate.translate(your_list[counter],
'%s-en' % lang))
counter = counter + 1
class TranslateService(BaseService):
#
# Public methods
def __init__(self):
self.engine = YandexTranslate(config.TRANSLATE_YANDEX_KEY)
BaseService.__init__(self)
def translate(self, text, direction):
"""
Translate text from foreign language on native.
This method tries to find translated word in own DB and if translate doesn't exists,
it sends request to external service
:param text: sentence to translate.
:param direction: Direction for translate. For example en-ru.
:return: translated text
"""
translation = self.get(text, direction)
if translation:
return translation
response = self.engine.translate(text, direction)
if response and response[u'code'] == 200:
return self.add(text, response)
raise TranslateError(response)
def get(self, text, direction):
"""
Try to find translation in DB
:param text: sentence to translate.
:param direction: Direction for translate. For example en-ru.
:return: translated text
"""
return self.db.Translation.find_one({'text': text, 'direction': direction})
def add(self, text, translation):
"""
Add to collection new translation
:param text: sentence to translate.
:param translation: response from translate.yandex.ru
:return: translated text
"""
ss = ServiceLocator.resolve(ServiceLocator.SESSIONS)
translation_entity = self.db.Translation()
translation_entity.direction = translation[u'lang']
translation_entity.text = text
translation_entity.variations = translation[u'text']
translation_entity.author = ss.get().login
try:
translation_entity.validate()
translation_entity.save()
return translation_entity
except Exception as ex:
error(u'Translate.add', ex)
return None
def detect(self, text):
"""
Detect language
:param text: text for which needs to detect language
:return: language
"""
return self.engine.detect(text)
class YandexTranslateTest(unittest.TestCase):
def setUp(self):
self.translate = YandexTranslate(
"trnsl.1.1.20130421T140201Z.323e508a" "33e9d84b.f1e0d9ca9bcd0a00b0ef71d82e6cf4158183d09e"
)
def test_directions(self):
directions = self.translate.directions
self.assertGreater(len(directions), 1)
def test_langs(self):
languages = self.translate.langs
self.assertEqual(
languages,
set(
[
u"el",
u"en",
u"ca",
u"it",
u"hy",
u"cs",
u"et",
u"az",
u"es",
u"ru",
u"nl",
u"pt",
u"no",
u"tr",
u"lv",
u"lt",
u"ro",
u"pl",
u"be",
u"fr",
u"bg",
u"hr",
u"de",
u"da",
u"fi",
u"hu",
u"sr",
u"sq",
u"sv",
u"mk",
u"sk",
u"uk",
u"sl",
]
),
)
def test_blocked_key(self):
translate = YandexTranslate(
"trnsl.1.1.20130723T112255Z.cfcd2b1ebae9f" "ff1.86f3d1de3621e69b8c432fcdd6803bb87ef0e963"
)
with self.assertRaises(YandexTranslateException, msg="ERR_KEY_BLOCKED"):
languages = translate.detect("Hello!")
def test_detect_language(self):
language = self.translate.detect(text="Hello, world!")
self.assertEqual(language, "en")
def test_translate(self):
result = self.translate.translate(u"Hello!", "ru")
self.assertEqual(result["text"][0], u"Здравствуйте!")
self.assertEqual(result["code"], 200)
def test_translate_in_another_direction(self):
result = self.translate.translate(u"Здравствуйте", "en")
self.assertEqual(result["text"][0], u"Hello")
self.assertEqual(result["code"], 200)
def test_language_detection_error(self):
with self.assertRaises(YandexTranslateException, msg="ERR_LANG_NOT_SUPPORTED"):
self.translate.detect("なのです")
# Yandex.Translate tries to translate this as english-to-russian
# def test_translate_error(self):
# with self.assertRaises(YandexTranslateException,
# msg="ERR_LANG_NOT_SUPPORTED"):
# self.translate.translate("なのです", "ru")
def test_without_key(self):
with self.assertRaises(
YandexTranslateException,
msg="Please, provide key for " "Yandex.Translate API: " "https://translate.yandex.ru/apikeys",
):
translate = YandexTranslate()
def test_error_long_text(self):
with self.assertRaises(YandexTranslateException, msg="ERR_TEXT_TOO_LONG"):
self.translate.translate("hi! " * 4098, "ru")
def test_invalid_key(self):
with self.assertRaises(YandexTranslateException, msg="ERR_KEY_INVALID"):
translate = YandexTranslate("my-invalid-key")
language = translate.detect("Hello!")
from yandex_translate import YandexTranslate
import language_codes
if __name__ == "__main__":
translate = YandexTranslate('trnsl.1.1.20160421T051442Z.3f43d13c5d30c594.bf3c396e87421e06cac7eab7b3771b3bf20af85c')
print ":speak: What do you want to translate?"
print ":listen:"
message = raw_input()
print "Translating {}".format(message)
language = translate.detect(message)
# translate from detected language to english
print ":speak:You are speaking {}".format(language_codes.languages[language])
translation = translate.translate(message, '{}-en'.format(language))
print translation
print ":speak:The english translation is {}".format(translation["text"][0])
def test_invalid_key(self):
with self.assertRaises(YandexTranslateException,
msg="ERR_KEY_INVALID"):
translate = YandexTranslate("my-invalid-key")
language = translate.detect("Hello!")
def analyze_tweet(request):
try:
#Instanciando o tradutor e a classe
Tweet.remover()
#translator = Translator() USAR COM GOOGLETRANS
results = Tweet()
results.remover() #Limpando novamente caso haja sujeira
#Coleta das informacoes fornecidas pelo HTML
texto = tira_emoji(request.POST.get('tweet_text'))
lang = request.POST.get('iso_language_code')
#Pega os links no texto, caso houver
links = get_links(texto)
#Remove os links no texto, caso houver
texto = del_links(texto)
#Esse aqui eh o yandex, funciona mas fico duvidoso por precisar dar str() --> USAR DE BACKUP
translate = YandexTranslate(
'trnsl.1.1.20180809T195441Z.ee8cb1461b193a37.718666e4f14fa0a45cf6e490af90863be18ab677'
)
lang = translate.detect(texto)
textoen = translate.translate(texto, 'en')
textobr = translate.translate(texto, 'pt')
textotraden = str(textoen.get('text'))
textotradbr = str(textobr.get('text'))
extras = str(textoen.get('code'))
'''
#Para a traducao EN
translationsen = translator.translate(['Erro na traducao EN', texto], dest='en')
for translationen in translationsen:
textotraden = translationen.text
lang = translationen.src
#Para a traducao BR
translationsbr = translator.translate(['Error at translating BR', texto], dest='pt')
for translationbr in translationsbr:
textotradbr = translationbr.text
extras = translationbr.extra_data
'''
#Polarizacao do texto traduzido
pol = unique_sentiment_score(textotraden)
#Da o setAll na classe usando a informacao do HTML
results.setAll(texto, textotraden, textotradbr, pol,
request.POST.get('profile_img_url'),
request.POST.get('name'), request.POST.get('url'),
request.POST.get('screen_name'), lang,
request.POST.get('followers_count'),
request.POST.get('friends_count'),
request.POST.get('favourites_count'),
request.POST.get('verified'), extras, links)
#Contexto de retorno para o HTML
context = {'results': results, 'text': request.POST.get('tweet_text')}
except KeyError:
return render(request, 'tcc/error.html')
else:
return render(request, 'tcc/tweet_analysis.html', context)
def get_person():
"""
Obtaining the average user according to the qualities of the different users in dataframe and making dictionaries of the
"""
df = pd.read_csv('users_connections.csv')
d = df.drop_duplicates('Friend ID').reset_index(drop=True) # getting dataframe without repitition of the users in the friend column
# You can get your own yandex key by passing through https://passport.yandex.com/auth/list?origin=translate&retpath=https%3A%2F%2Ftranslate.yandex.com%2Fdevelopers%2Fkeys&mode=edit
translate = YandexTranslate('trnsl.1.1.20200101T142004Z.5ca473d122ac01d7.151c6a9995eb8e52c98d75ad3f266addd27137d9') # initializing translater
print("Starting analysis...")
print("Analysis of the user's sex")
sexes = {}
for i in range(d.shape[0]): # getting the dictionary of the users' sexes and ther quantity
if d['Friend\'s sex'][i] != 0: # checking if the sex is indicated
if d['Friend\'s sex'][i] not in sexes: # checking if founded sex is in the dictionary or not
sexes[d['Friend\'s sex'][i]] = 1 # adding to dictionary if not
else:
sexes[d['Friend\'s sex'][i]] += 1 # incrementing quantity if it is in dictionary
rand_sex = random.randrange(0, len(max_items(sexes))) # randomizing the gender number as the quantity of the users' sexes can be equal
if max_items(sexes)[rand_sex] == 1: # getting one of sexes with the highest quantity and translating it as string
sex = "Female"
else:
sex = "Male"
print("Analysis of the user's full name")
first_names, last_names = {}, {}
for i in range(d.shape[0]): # getting the dictionary of the users' first and last names and ther quantity with respect to selected sex
if d['Friend\'s sex'][i] == max_items(sexes)[rand_sex]: # checking if the name and surname are appropriate according to the sex (ex. if sex is male => name should be for men)
name = unidecode.unidecode(d['Friend\'s first name'][i]) # rewriting the name into english alphabet
if name not in first_names: # adding usage quantity if the name is not in the dictionary or incrementing the quantity if it there
first_names[name] = 1
else:
first_names[name] += 1
surname = unidecode.unidecode(d['Friend\'s last name'][i]) # the same procedure as for the name
if surname not in last_names:
last_names[surname] = 1
else:
last_names[surname] += 1
rand_name = random.randrange(0, len(max_items(first_names))) # randomizing the name number as the quantity of the users' names can be equal
name = max_items(first_names)[rand_name] # getting one of names with the highest quantity and translating it as string
rand_surname = random.randrange(0, len(max_items(last_names))) # randomizing the surname number as the quantity of the users' surnames can be equal
surname = max_items(last_names)[rand_surname] # getting one of surnames with the highest quantity and translating it as string
print("Analysis of the user's birthday")
birth_day, birth_month, birth_year = {}, {}, {}
for i in range(d.shape[0]): # getting the dictionary of the users' day, month and year of birth and their quantities
if d['Friend\'s birthday'][i] != '0': # checking if the birthday is indicated
birthday = d['Friend\'s birthday'][i].split('.') # spliting indicated birthday date by day, month and year
for j in range(len(birthday)):
if j == 0: # if the day is indicated
if birthday[j] not in birth_day: # checks whether it is in dictionary or not, increments if it is there
birth_day[birthday[j]] = 1
else:
birth_day[birthday[j]] += 1
elif j == 1: # same as for day
if birthday[j] not in birth_month:
birth_month[birthday[j]] = 1
else:
birth_month[birthday[j]] += 1
elif j == 2: # same as for day
if birthday[j] not in birth_year:
birth_year[birthday[j]] = 1
else:
birth_year[birthday[j]] += 1
rand_day = random.randrange(0, len(max_items(birth_day))) # randomizing the number of the day of birth as the quantity of the users' day of birth can be equal
rand_month = random.randrange(0, len(max_items(birth_month))) # randomizing the number of the month of birth as the quantity of the users' month of birth can be equal
rand_year = random.randrange(0, len(max_items(birth_year))) # randomizing the number of the year of birth as the quantity of the users' year of birth can be equal
birthday = max_items(birth_day)[rand_day]+'.'+max_items(birth_month)[rand_month]+'.'+max_items(birth_year)[rand_year] # getting final date of birth
print("Analysis of the user's living country and city")
countries= {}
for i in range(d.shape[0]): # getting the dictionary of the countries where users live and their quantities
if d['Country'][i] != '0': # checking if the country is indicated
res = ast.literal_eval(d['Country'][i]) # checking the string value and rewriting it to the python expression, if it is one of them, in our case it is dictionary
if 'title' in res: # checking if the title of the country is indicated
if res['title'] not in countries: # checking if the title is in the dictionary or not and increments if it is there
countries[res['title']] = 1
else:
countries[res['title']] += 1
rand_country = random.randrange(0, len(max_items(countries)))
country = max_items(countries)[rand_country] # getting random selected country from the list of the countries with the maximum users in it
cities = {}
for i in range(d.shape[0]): # getting the dictionary of the cities where users live with respect of the selected country and their quantities
if d['Country'][i] != '0': # checking firstly if the country is indicated
res = ast.literal_eval(d['Country'][i])
if 'title' in res:
if res['title'] == max_items(countries)[rand_country]: # checking if the city belongs to the selected country in order to avoid misleadings
if d['City'][i] != '0': # cheking if the city is indicated
res = ast.literal_eval(d['City'][i]) # rewriting string into dictionary
if 'title' in res: # checking if the title of the city is indicated
if res['title'] not in cities: # manipulating with dictionary
cities[res['title']] = 1
else:
cities[res['title']] += 1
rand_city = random.randrange(0, len(max_items(cities)))
city = max_items(cities)[rand_city] # getting random selected city from the list of the cities with the maximum users in it
print("Analysis of the user's personal info and translating in english")
langs, political, religions, inspired_by, people_main, life_main, smoking, alcohol = {}, {}, {}, {}, {}, {}, {}, {}
# Getting dictionaries of the diffent personal information and their number in users profile
for i in range(d.shape[0]):
p = d['Friend\'s personal info'][i]
if p != '0': # checking if the personal info is indicated
res = ast.literal_eval(p) # rewriting it into dictionary
if 'langs' in res: # checking if the languages are indicated
for j in range(len(res['langs'])): # going throungh all the mentioned languages and manipulating with dictionary
if res['langs'][j] not in langs:
langs[res['langs'][j]] = 1
else:
langs[res['langs'][j]] += 1
if 'political' in res: # checking if the political interests are indicated
if res['political'] not in political: # manipulating with dictionary
political[res['political']] = 1
else:
political[res['political']] += 1
if 'religion' in res and res['religion'] != '': # checking if the religion is mentioned and it is not empty string
try: # trying to translate mentioned religion name while finding the original language
text = translate.translate(res['religion'], translate.detect(res['religion'])+'-en')['text'][0].title()
except: # if the original language of the writings is not found or any other exception, using default translation
text = translate.translate(res['religion'], 'ru-en')['text'][0].title() # default translation could be changed
if text not in religions: # manipulating with the dictionary
religions[text] = 1
else:
religions[text] += 1
if 'inspired_by' in res: # checking if the inspirations are indicated
text = remove_emoji(res['inspired_by']) # removing emojis and unneccessary symbols
words = re.sub('[!@#$.«»()%^&*_=+"<>:;]', '', text).split(", ") # spliting text by ', ' to get different inspirations
for w in words: # checking and manipulating with each phrase
try: # trying to translate and capitalising each word
w = translate.translate(w,translate.detect(w)+'-en')['text'][0].title()
except:
w = translate.translate(w,'ru-en')['text'][0].title()
if " And " in w: # if there is And in the phrase then we are spliting again
ph = w.split(" And ")
for j in ph:
if j not in inspired_by:
inspired_by[j] = 1
else:
inspired_by[j] += 1
else:
if w not in inspired_by:
inspired_by[w] = 1
else:
inspired_by[w] += 1
if 'people_main' in res: # almost the same procedure as for the previous attributes
if res['people_main'] != 0:
if res['people_main'] not in people_main:
people_main[res['people_main']] = 1
else:
people_main[res['people_main']] += 1
if 'life_main' in res:
if res['life_main'] != 0:
if res['life_main'] not in life_main:
life_main[res['life_main']] = 1
else:
life_main[res['life_main']] += 1
if 'smoking' in res:
if res['smoking'] != 0:
if res['smoking'] not in smoking:
smoking[res['smoking']] = 1
else:
smoking[res['smoking']] += 1
if 'alcohol' in res:
if res['alcohol'] != 0:
if res['alcohol'] not in alcohol:
alcohol[res['alcohol']] = 1
else:
alcohol[res['alcohol']] += 1
languages = max_four_lang(langs) # getting the first four languages with the highest usage
# Getting personal information with the highest number of appearance in the user's profile
polit_poss = ['Communistic','Socialistic','Moderate','Liberal','Conservative','Monarchical','Ultraconservative','Indifferent','Libertarian']
rand_polit = random.randrange(0, len(max_items(political)))
political_interest = polit_poss[int(max_items(political)[rand_polit])-1]
rand_rel = random.randrange(0, len(max_items(religions)))
religion = max_items(religions)[rand_rel]
rand_insp = random.randrange(0, len(max_items(inspired_by)))
inspiration = max_items(inspired_by)[rand_insp]
peop_qual = ['Mind and creativity','Kindness and honesty','Health and beauty','Power and wealth','Courage and perseverance','Humor and love of life']
rand_peop = random.randrange(0, len(max_items(people_main)))
main_in_people = peop_qual[int(max_items(people_main)[rand_peop])-1]
life_prior = ['Family and children','Career and money','Entertainment and relaxation','Science and research','Perfecting the world','Self development','Beauty and art','Fame and influence']
rand_life = random.randrange(0, len(max_items(life_main)))
main_in_life = life_prior[int(max_items(life_main)[rand_life])-1]
smoke_rel = ['Sharply negative','Negative','Compromise','Neutral','Positive']
rand_smoke = random.randrange(0, len(max_items(smoking)))
relation_to_smoking = smoke_rel[int(max_items(smoking)[rand_smoke])-1]
alc_rel = ['Sharply negative','Negative','Compromise','Neutral','Positive']
rand_alc = random.randrange(0, len(max_items(alcohol)))
relation_to_alcohol = alc_rel[int(max_items(alcohol)[rand_alc])-1]
print("Analysis of the user's higher education")
# Getting information about university
university_names = {}
for i in range(d.shape[0]):
if d['Universities'][i] != '0': # checking if the university is mentioned
resList = ast.literal_eval(d['Universities'][i]) # changing it into list firstly
if res != []: # if the list of the universities is not empty
for uni in resList:
resDict = ast.literal_eval(str(uni)) # change each mentioned university to dictionary
if 'name' in resDict: # cheking if the name of the university is indicated and manipulating with dictionary
if resDict['name'] not in university_names:
university_names[resDict['name']] = 1
else:
university_names[resDict['name']] += 1
rand_uni_name = random.randrange(0, len(max_items(university_names)))
university_name = max_items(university_names)[rand_uni_name]
# Finding faculty name according to the selected university
faculty_names = {}
for i in range(d.shape[0]): # almost the same procedure as for the names of the universities
if d['Universities'][i] != '0':
resList = ast.literal_eval(d['Universities'][i])
if res != []:
for uni in resList:
resDict = ast.literal_eval(str(uni))
if 'name' in resDict:
if resDict['name'] == university_name: # checking for the faculties only in selected university
if 'faculty_name' in resDict and resDict['faculty_name'] != '':
fac_name = translate.translate(resDict['faculty_name'], translate.detect(resDict['faculty_name'])+'-en')['text'][0]
if fac_name not in faculty_names:
faculty_names[fac_name] = 1
else:
faculty_names[fac_name] += 1
rand_fac_name = random.randrange(0, len(max_items(faculty_names)))
faculty_name=translate.translate(max_items(faculty_names)[rand_fac_name],translate.detect(max_items(faculty_names)[rand_fac_name])+'-en')['text'][0].title()
personality = [name,surname,sex,birthday,country,city,languages,political_interest,religion,inspiration,main_in_people,main_in_life,relation_to_smoking,relation_to_alcohol,university_name,faculty_name]
return personality, first_names,last_names,sexes,countries,cities,langs,political, religions, inspired_by,people_main, life_main, smoking, alcohol, university_names,faculty_names
keywords.append(interests[i].split(','))
print("{:<5} {:<25} {:<10} {:<25}".format('#', 'KEYWORD', 'LANGUAGE',
'TRANSLATION'))
translated = []
step = 1
for i in range(0, len(keywords)):
for k in range(0, len(keywords[i])):
keywords[i][k] = re.sub("' | '", "", keywords[i][k])
keywords[i][k] = keywords[i][k].replace("'", "")
keywords[i][k] = keywords[i][k].replace('"', "")
keywords[i][k] = keywords[i][k].replace("[", "")
keywords[i][k] = keywords[i][k].replace("]", "")
keywords[i][k] = keywords[i][k].lower().lstrip()
language = translate.detect(keywords[i][k])
if language != 'en':
translation = translate.translate(keywords[i][k], 'en')
print("{:<5} {:<25} {:<10} {:<25}".format(step, keywords[i][k],
language,
translation['text'][0]))
translated.append(translation['text'][0])
step += 1
else:
translated.append(keywords[i][k])
with open('translated_keywords.csv', 'w', encoding="utf-8", newline='') as f:
writer = csv.writer(f, quoting=csv.QUOTE_NONE)
writer.writerow(['KEYWORD'])
if translated != []:
for i in translated:
def detect_lang(self, text):
translator = YandexTranslate(self.yandex_api_key)
return translator.detect(text)
from yandex_translate import YandexTranslate
translate = YandexTranslate(
'Y"trnsl.1.1.20130421T140201Z.323e508a""33e9d84b.f1e0d9ca9bcd0a00b0ef71d82e6cf4158183d09e.'
)
print('Languages:', translate.langs)
print('Translate directions:', translate.directions)
print('Detect language:', translate.detect('Привет, мир!'))
print('Translate:', translate.translate(
'Привет, мир!',
'ru-en')) # or just 'en'from yandex_translate import YandexTranslate
translate = YandexTranslate('Your API key here.')
print('Languages:', translate.langs)
print('Translate directions:', translate.directions)
print('Detect language:', translate.detect('Привет, мир!'))
print('Translate:', translate.translate('Привет, мир!',
'ru-en')) # or just 'en'
def detect_language_text(text):
translate = YandexTranslate(settings.YANDEX_TRANSLATE_API_KEY)
part_text = text[1:50]
return translate.detect(part_text)
def test_blocked_key(self):
translate = YandexTranslate(
"trnsl.1.1.20130723T112255Z.cfcd2b1ebae9f" "ff1.86f3d1de3621e69b8c432fcdd6803bb87ef0e963"
)
with self.assertRaises(YandexTranslateException, msg="ERR_KEY_BLOCKED"):
languages = translate.detect("Hello!")
def collect(request):
try:
#Busca das informacoes de search.html
op = request.POST.get('op') #Opcao do usuario
search = request.POST.get('search') #Texto do usuario
#translator = Translator() USAR COM GOOGLETRANS
#Setup do collect
Tweet.remover() #Limpar a classe Tweet
api = setup() #Deixar a API pronta
if (op == "1"): #Opcao de analise bruta
#Setar as variaveis
count = 40 #Quantos tweets vai pegar
past = 0 #Quantos tweets nao foram polarizados
posTot = 0 #Total positivo
neuTot = 0 #Total negativo
negTot = 0 #Total neutro
comTot = 0 #Total geral
#Filtro e busca
filter = " -filter:retweets" #Nao podemos aceitar retweets pois eles sujam os dados com repeticao de um mesmo tweet
newsearch = "".join(
(search, filter)) #Junta a pesquisa do usuario com o filtro
tweets = tweepy.Cursor(api.search,
q=newsearch,
count=count,
tweet_mode="extended").items(
count) #Faz a coleta do tweepy
count = 0 #Zerar para caso tenha menos de 20 tweets
#Iterar pelos tweets
for tweet in tweets:
count += 1 #Cada tweet adiciona um
#Setando a classe
analysis = Tweet()
#Retirar os emojis do texto
texto = tira_emoji(tweet.full_text)
#Esse aqui eh o yandex, funciona mas fico duvidoso por precisar dar str() --> USAR DE BACKUP
translate = YandexTranslate(
'trnsl.1.1.20180809T195441Z.ee8cb1461b193a37.718666e4f14fa0a45cf6e490af90863be18ab677'
)
lang = translate.detect(texto)
textoen = translate.translate(texto, 'en')
textobr = translate.translate(texto, 'pt')
textotraden = str(textoen.get('text'))
textotradbr = str(textobr.get('text'))
extras = str(textoen.get('code'))
'''
#Para a traducao EN
translationsen = translator.translate(['Erro na traducao EN', texto], dest='en')
for translationen in translationsen:
textotraden = translationen.text
lang = translationen.src
#Para a traducao BR
translationsbr = translator.translate(['Error at translating BR', texto], dest='pt')
for translationbr in translationsbr:
textotradbr = translationbr.text
extras = translationbr.extra_data
'''
#Polarizacao
pol = unique_sentiment_score(textotraden)
#Dar o setALL na classe Tweet
analysis.setAll(texto,
textotraden,
textotradbr,
pol,
tweet.user.profile_image_url_https,
tweet.user.name,
tweet.user.url,
tweet.user.screen_name,
lang,
tweet.user.followers_count,
tweet.user.friends_count,
tweet.user.favourites_count,
tweet.user.verified,
extras,
links="")
#Salvar os dados do setAll para ler no HTML
analysis.save()
#Caso a polarizacao falhe e neutralidade de 1
if pol['neu'] == 1:
pol['neu'] = 0 #Impede que a neutralidade suje os dados
count -= 1 #Retira do total de tweets
past += 1 #Adiciona nos tweets sem polaridade
#Adicionando os valores para os graficos
posTot += pol['pos']
negTot += pol['neg']
neuTot += pol['neu']
comTot += pol['compound']
#Media dos valores totais para os graficos
posTot = float(posTot / count)
negTot = float(negTot / count)
neuTot = float(neuTot / count)
comTot = float(comTot / count)
#Contexto de retorno para o HTML
context = {
'posTot': posTot,
'negTot': negTot,
'neuTot': neuTot,
'comTot': comTot,
'count': count,
'past': past,
'analysis': analysis.all(),
'query': search,
}
elif (op == "2"): #Se voce escolheu pesquisa livre
#Filtro e busca
filter = " -filter:retweets" #Nao podemos aceitar retweets pois eles sujam os dados com repeticao de um mesmo tweet
newsearch = "".join(
(search, filter)) #Junta a pesquisa do usuario com o filtro
tweets = tweepy.Cursor(api.search,
q=newsearch,
count=40,
tweet_mode="extended").items(
40) #Faz a coleta do tweepy
#se não houve resultado, manda para nothing.html AMANDA PAROU AQUI AAAAAAAA
#if not tweets:
#return render(request, 'tcc/nothing.html')
#Contexto de retorno para o HTML
context = {
'tweets': tweets,
'query': search,
}
else: #Se voce escolheu pesquisa direcionada por usuario
users = api.search_users(q=search,
count=100) #Faz a coleta do tweepy
#se não houve resultado, manda para nothing.html
if not users:
return render(request, 'tcc/nothing.html')
#Contexto de retorno para o HTML
context = {
'users': users,
'query': search,
}
except ZeroDivisionError:
return render(request, 'tcc/nothing.html')
except tweepy.TweepError:
return render(request, 'tcc/error.html')
except KeyError:
return render(request, 'tcc/error.html')
else:
return render(request, 'tcc/result_list.html', context)
authors.append((row["AUTHOR"]))
titles.append(row["TITLE"])
abstracts.append(row["ABSTRACT"])
texts = []
for i in range(0, len(titles)):
content = titles[i] + '. ' + abstracts[i]
texts.append(content)
step = 1
translated = []
with open('2_abs_translated.csv', 'wb') as f:
writer = csv2.writer(f)
writer.writerow(["AUTHOR", "YEAR", "LANGUAGE", "ABSTRACT", "TRANSLATED_ABSTRACT"])
for text in range(0, len(texts)):
language = translate.detect(texts[text])
if language != 'en':
translation = translate.translate(texts[text], 'en')
print(step, '\n',
'ABSTRACT: ', texts[text], '\n',
'LANGUAGE: ', language, '\n',
'TRANSLATION: ',translation['text'][0])
writer.writerow([authors[text], years[text], language,
texts[text], translation['text'][0]])
else:
print(step, '\n',
'ABSTRACT: ', texts[text], '\n',
'LANGUAGE: ', language)
writer.writerow([authors[text], years[text], language,
texts[text], texts[text]])
step += 1
def analyze_user(request):
try:
#Setar as variaveis que serap usadas e o count de qntos tweets vai pegar
count = 40
past = 0
posTot = 0
neuTot = 0
negTot = 0
comTot = 0
#Limpar a classe e instanciar as apis
Tweet.remover()
api = setup()
#translator = Translator() USAR COM GOOGLETRANS
#Busca de tweets e instanciamento das ferramentas
tweets = api.user_timeline(screen_name=request.POST.get('name'),
count=count,
tweet_mode="extended")
count = 0 #Zerar para caso tenha menos de 20 tweets
for tweet in tweets:
count += 1 #Cada tweet adiciona um
#Setando a classe para um tweet
analysis = Tweet()
#Retirar os emojis do texto pois eles dao crash no app
full_text_emojiless = tira_emoji(tweet.full_text)
#Esse aqui eh o yandex, funciona mas fico duvidoso por precisar dar str() --> USAR DE BACKUP
translate = YandexTranslate(
'trnsl.1.1.20180809T195441Z.ee8cb1461b193a37.718666e4f14fa0a45cf6e490af90863be18ab677'
)
lang = translate.detect(full_text_emojiless)
textoen = translate.translate(full_text_emojiless, 'en')
textobr = translate.translate(full_text_emojiless, 'pt')
textotraden = str(textoen.get('text'))
textotradbr = str(textobr.get('text'))
extras = str(textoen.get('code'))
'''
#Para a traducao EN
translationsen = translator.translate(['Erro na traducao EN', full_text_emojiless], dest='en')
for translationen in translationsen:
textotraden = translationen.text
lang = translationen.src
#Para a traducao BR
translationsbr = translator.translate(['Error at translating BR', full_text_emojiless], dest='pt')
for translationbr in translationsbr:
textotradbr = translationbr.text
extras = translationbr.extra_data
'''
#Para a polarizacao
pol = unique_sentiment_score(textotraden)
#Dar o setAll nas informacoes criadas nessa funcao
analysis.setAll(full_text_emojiless,
textotraden,
textotradbr,
pol,
tweet.user.profile_image_url_https,
tweet.user.name,
tweet.user.url,
tweet.user.screen_name,
lang,
tweet.user.followers_count,
tweet.user.friends_count,
tweet.user.favourites_count,
tweet.user.verified,
extras,
links="")
#Salvar os dados na classe
analysis.save()
#Caso a polarizacao falhe e neutralidade de 1
if pol['neu'] == 1:
pol['neu'] = 0 #Impede que a neutralidade suje os dados
count -= 1 #Retira do total de tweets
past += 1 #Adiciona nos tweets sem polaridade
#Adicionando os valores para os graficos
posTot += pol['pos']
negTot += pol['neg']
neuTot += pol['neu']
comTot += pol['compound']
#Fazer as medias de cada valor geral para os graficos
posTot = float(posTot / count)
negTot = float(negTot / count)
neuTot = float(neuTot / count)
comTot = float(comTot / count)
#Contexto de retorno para o HTML
context = {
'posTot': posTot,
'negTot': negTot,
'neuTot': neuTot,
'comTot': comTot,
'count': count,
'past': past,
'analysis': analysis.all(),
'query': request.POST.get('name'),
}
except tweepy.TweepError:
return render(request, 'tcc/user_protected.html')
except KeyError:
return render(request, 'tcc/error.html')
else:
return render(request, 'tcc/user_analysis.html', context)
class YandexTranslateTest(unittest.TestCase):
def setUp(self):
self.translate = YandexTranslate(
"trnsl.1.1.20130421T140201Z.323e508a"
"33e9d84b.f1e0d9ca9bcd0a00b0ef71d82e6cf4158183d09e")
def test_directions(self):
directions = self.translate.directions
self.assertGreater(len(directions), 1)
def test_langs(self):
languages = self.translate.langs
self.assertEqual(
languages,
set([
u"el", u"en", u"ca", u"it", u"hy", u"cs", u"et", u"az", u"es",
u"ru", u"nl", u"pt", u"no", u"tr", u"lv", u"lt", u"ro", u"pl",
u"be", u"fr", u"bg", u"hr", u"de", u"da", u"fi", u"hu", u"sr",
u"sq", u"sv", u"mk", u"sk", u"uk", u"sl"
]))
def test_blocked_key(self):
translate = YandexTranslate(
"trnsl.1.1.20130723T112255Z.cfcd2b1ebae9f"
"ff1.86f3d1de3621e69b8c432fcdd6803bb87ef0e963")
with self.assertRaises(YandexTranslateException,
msg="ERR_KEY_BLOCKED"):
languages = translate.detect("Hello!")
def test_detect_language(self):
language = self.translate.detect(text="Hello, world!")
self.assertEqual(language, "en")
def test_translate(self):
result = self.translate.translate(u"Hello!", "ru")
self.assertEqual(result["text"][0], u"Здравствуйте!")
self.assertEqual(result["code"], 200)
def test_translate_in_another_direction(self):
result = self.translate.translate(u"Здравствуйте", "en")
self.assertEqual(result["text"][0], u"Hello")
self.assertEqual(result["code"], 200)
def test_language_detection_error(self):
with self.assertRaises(YandexTranslateException,
msg="ERR_LANG_NOT_SUPPORTED"):
self.translate.detect("なのです")
# Yandex.Translate tries to translate this as english-to-russian
# def test_translate_error(self):
# with self.assertRaises(YandexTranslateException,
# msg="ERR_LANG_NOT_SUPPORTED"):
# self.translate.translate("なのです", "ru")
def test_without_key(self):
with self.assertRaises(YandexTranslateException,
msg="Please, provide key for " \
"Yandex.Translate API: " \
"https://translate.yandex.ru/apikeys"):
translate = YandexTranslate()
def test_error_long_text(self):
with self.assertRaises(YandexTranslateException,
msg="ERR_TEXT_TOO_LONG"):
self.translate.translate("hi! " * 4098, "ru")
def test_invalid_key(self):
with self.assertRaises(YandexTranslateException,
msg="ERR_KEY_INVALID"):
translate = YandexTranslate("my-invalid-key")
language = translate.detect("Hello!")