/// <summary>
/// Translate
/// </summary>
/// <returns></returns>
private async Task Translate()
{
GoogleTranslator translator = new GoogleTranslator();
GoogleTranslateFreeApi.Language languageFrom = GoogleTranslateFreeApi.Language.Auto;
// GoogleTranslateFreeApi.Language languageTo = GoogleTranslator.GetLanguageByName("Korean");
GoogleTranslateFreeApi.Language languageTo = GoogleTranslator.GetLanguageByName(SelectTranslate(comboBox_LanguageTrans.SelectedIndex));
try
{
// TranslateAsync TranslateLiteAsync
TranslationResult translationResult = await translator.TranslateLiteAsync(textBox_Extract.Text, languageFrom, languageTo);
string[] strResultSeparated = translationResult.FragmentedTranslation;
string strTranslate = "";
foreach (string strtmp in strResultSeparated)
{
strTranslate += (strtmp + "\n");
}
label_ErrorTranslate.Visible = false;
textBox_Translate.Text = strTranslate;
}
catch (Exception)// ex)
{
label_ErrorTranslate.Visible = true;
textBox_Translate.Text = "";
}
}
static void Main(string[] args)
{
Language english = GoogleTranslator.GetLanguageByName("English"); // define language this way
Language russian = Language.Russian; // or even this way
Language french = GoogleTranslator.GetLanguageByISO("fr"); // you could also use ISO639 value
TranslationResult result = Translator.TranslateAsync("Hello. How are you?", english, russian).GetAwaiter().GetResult();
Console.WriteLine($"Result 1: {result.MergedTranslation}");
TranslationResult result2 =
Translator.TranslateAsync(new TranslateItem("The quick brown fox jumps over the lazy dog. Brown fox"))
.GetAwaiter()
.GetResult();
for (var i = 0; i < result2.FragmentedTranslation.Length; i++)
{
var part = result2.FragmentedTranslation[i];
Console.WriteLine($"Result 2.{i} = {part}");
}
TranslationResult result3 =
Translator.TranslateAsync("Run", english, Language.Dutch)
.GetAwaiter()
.GetResult();
foreach (var noun in result3.ExtraTranslations.Noun)
{
Console.WriteLine($"{noun.Phrase}: {string.Join(", ", noun.PhraseTranslations)}");
}
}
public static List <Item> ConvertToList(DataTable dt)
{
var items = new List <Item>();
var rowIndex = 0;
rowIndex++; // pass headers
foreach (DataRow row in dt.Rows)
{
rowIndex++;
var trValues = (row["MessageText"] + "").Trim();
if (string.IsNullOrWhiteSpace(trValues))
{
continue;
}
var en = GoogleTranslator.TranslateTurkishToEnglish(trValues);
if (string.IsNullOrWhiteSpace(en))
{
continue;
}
var propName = GoogleTranslator.CreatePropertyNameFromSentence(en);
items.Add(new Item {
NameTR = trValues, ExcelRowIndex = rowIndex, NameEN = propName
});
}
return(items);
}
public async Task TranslateAsync([Remainder][Summary("The sentence")] string sentence)
{
var translator = new GoogleTranslator();
Language from = Language.Auto;
Language to = Language.English;
TranslationResult result = await translator.TranslateAsync(sentence, from, to).ConfigureAwait(false);
double confidence = Math.Round(double.Parse(result.LanguageDetections[0].Confidence.ToString()) * 100, 2);
EmbedBuilder eb = new EmbedBuilder
{
Title = "Translation",
Description = $"Sentence: {result.OriginalText}\nLanguage detected: {result.LanguageDetections[0].Language.FullName} ({confidence}% confident)",
Color = Color.Green
};
eb.AddField("In English", result.MergedTranslation);
if (result.OriginalTextTranscription != null)
{
eb.AddField("Transcription", result.OriginalTextTranscription);
}
if (result.Synonyms != null)
{
eb.AddField("Synonyms", result.Synonyms.ToString());
}
eb.WithFooter(footer =>
{
footer.Text = "Google Translate";
});
await RankaReplyAsync(eb).ConfigureAwait(false);
}
public async Task Translate(string sourceLanguageISO, string targetLanguageISO, [Multiword] string input)
{
var fromLanguage = GoogleTranslator.GetLanguageByISO(sourceLanguageISO);
var toLanguage = GoogleTranslator.GetLanguageByName(targetLanguageISO);
await ProcessTranslation(fromLanguage, toLanguage, input).ConfigureAwait(false);
}
public Task ScholarAsync([Remainder][Summary("The search query")] string query)
{
string mentions = String.Empty;
List <long> userHis = new List <long>();
foreach (string tag in query.Split(" "))
{
AddUserHistory(tag, Context.User.Id);
if (UserHistory.ContainsKey(tag))
{
foreach (long idTag in UserHistory[tag])
{
if (!userHis.Contains(idTag))
{
userHis.Add(idTag);
}
}
}
}
foreach (long ids in userHis)
{
mentions += $"<@{ids}> ";
}
GoogleTranslator translator = new GoogleTranslator();
TranslationResult portuguese = translator.TranslateLiteAsync(query, Language.English, Language.Portuguese).GetAwaiter().GetResult();
TranslationResult english = translator.TranslateLiteAsync(query, Language.Portuguese, Language.English).GetAwaiter().GetResult();
return(ReplyAsync($"Pesquisa em portugues: https://scholar.google.com/scholar?q={portuguese.MergedTranslation.Replace("+", "%2B").Replace(' ', '+')} \nEnglish search: https://scholar.google.com/scholar?q={english.MergedTranslation.Replace("+", "%2B").Replace(' ', '+')}\n Outra pessoa que tambem pesquisou: {mentions}"));
}
private static async Task Translate(FileInfo resxFile, string from, string to)
{
var content = root.Load(resxFile);
var destination = root.Load(resxFile);
var novoArquivo = Path.Combine(resxFile.Directory.FullName,
Path.GetFileNameWithoutExtension(resxFile.Name).Replace(from, to) + Path.GetExtension(resxFile.Name));
if (File.Exists(novoArquivo))
{
return;
}
var translator = new GoogleTranslator();
var languageFrom = GoogleTranslator.GetLanguageByISO(from.ToLower());
var languageTo = GoogleTranslator.GetLanguageByISO(to.ToLower());
foreach (var rootData in content.data)
{
var result = await translator.TranslateLiteAsync(rootData.value, languageFrom, languageTo);
destination.data.First(f => f.name == rootData.name).value = result.MergedTranslation;
Console.WriteLine($"{rootData.name} - {rootData.value} -> {result.MergedTranslation}");
}
destination.SerializeTo(novoArquivo);
}
private static async Task <string> Translate(string buf)
{
int retry = 10;
var buf_escaped = Regex.Escape(buf);
if (lookup.ContainsKey(buf_escaped))
{
Console.WriteLine("Cache hit! " + buf_escaped);
return(Regex.Unescape(lookup[buf_escaped]));
}
while (retry != 0)
{
try
{
Language from = Language.Auto;
Language to = GoogleTranslator.GetLanguageByName("Korean");
TranslationResult result = await _translator.TranslateLiteAsync(buf, from, to);
string resultMerged = result.MergedTranslation;
var translated_escpaed = Regex.Escape(resultMerged);
lookup[buf_escaped] = translated_escpaed;
Save();
return(resultMerged);
}
catch (Exception error)
{
_translator = new GoogleTranslator();
Console.WriteLine(error);
retry--;
}
}
return("ERROR");
}
private static List <Show> GetShows(ILogger logger)
{
var config = Config.GetInstance();
CacheManagerBase fileCache;
if (config.TranslatorCacheSettings != null)
{
fileCache = new FileCacheManager(config.TranslatorCacheSettings.OutputFile);
}
else
{
fileCache = new DummyCacheManager();
}
var lst = new List <Show>();
if (config.Grabbers.Count == 0)
{
Console.WriteLine("No grabbers defined in config");
}
else
{
foreach (var grabber in config.Grabbers)
{
try
{
var a = Assembly.LoadFrom(grabber.Path);
foreach (var t in a.GetTypes())
{
if (t.IsSubclassOf(typeof(GrabberBase)))
{
var gb = (GrabberBase)Activator.CreateInstance(t);
var shows = gb.Grab(grabber.Parameters, Logger);
if (!string.IsNullOrEmpty(grabber.ChannelPrefix))
{
shows.ForEach(x => x.Channel = grabber.ChannelPrefix + x.Channel);
}
if (grabber.Translation != null)
{
Logger.WriteEntry("Starting translation of " + t.FullName, LogType.Info);
var g = new GoogleTranslator(fileCache);
g.TranslateShows(shows, grabber.Translation.From, grabber.Translation.To, logger);
Logger.WriteEntry("Finished translation of " + t.FullName, LogType.Info);
}
lst.AddRange(shows);
}
}
}
catch (Exception ex)
{
Logger.WriteEntry("error on grabber " + grabber.Path + " " + ex.Message, LogType.Error);
if (config.HaltOnGrabberError)
{
throw ex;
}
}
}
}
return(lst);
}
public WebTranslator(ILog logger)
{
_Logger = logger;
if (!Helper.LoadStaticFromJson(typeof(GlobalTranslationSettings), _TransaltionSettingsPath))
{
Helper.SaveStaticToJson(typeof(GlobalTranslationSettings), _TransaltionSettingsPath);
Helper.LoadStaticFromJson(typeof(GlobalTranslationSettings), _TransaltionSettingsPath);
}
transaltionCache = new List <KeyValuePair <TranslationRequest, string> >(GlobalTranslationSettings.TranslationCacheSize);
_MultillectTranslator = new MultillectTranslator(_Logger);
_GoogleTranslator = new GoogleTranslator(_Logger);
_YandexTranslator = new YandexTranslator(_Logger);
_DeepLTranslator = new DeepLTranslator(_Logger);
_PapagoTranslator = new PapagoTranslator(_Logger);
_BaiduTranslator = new BaiduTranslater(_Logger);
_LanguageDetector = new LanguageDetector(GlobalTranslationSettings.MaxSameLanguagePercent,
GlobalTranslationSettings.NTextCatLanguageModelsPath, _Logger);
}
public void Run(IrcMessage theMessage)
{
string target = theMessage.CommandArgs.First().ToLower();
string word = theMessage.CommandArgs.Skip(1).Join(" ");
if (target.Length != 2)
{
target = "en";
word = theMessage.CommandArgs.Join(" ");
}
Translation translation = GoogleTranslator.GetTranslation(word, target, "");
if (String.IsNullOrEmpty(translation?.FullTranslation))
{
theMessage.Answer("Das hat nicht so geklappt wie erwartet");
return;
}
if (translation.dict != null && theMessage.CommandArgs.Count(x => x != "en") == 1)
{
StringBuilder sb = new StringBuilder(translation.FullTranslation);
foreach (Dic item in translation.dict)
{
sb.AppendFormat(" - {0}: {1}", item.pos, item.terms.Take(5).Join(", "));
}
theMessage.Answer(sb.ToString());
}
else if (!String.IsNullOrEmpty(translation.FullTranslation))
{
theMessage.Answer(translation.FullTranslation);
}
}
public async Task <string> TranslateTextAsync(string input)
{
var translator = new GoogleTranslator();
int selection = comboBox1.SelectedIndex;
GoogleTranslateFreeApi.Language from;
if (selection == 0)
{
from = GoogleTranslateFreeApi.Language.Auto;
}
else
{
from = GoogleTranslator.GetLanguageByName(languages[comboBox1.SelectedIndex].name);
}
GoogleTranslateFreeApi.Language to = GoogleTranslator.GetLanguageByName(languages[comboBox2.SelectedIndex].name);
TranslationResult result = await translator.TranslateAsync(input, from, to);
//The result is separated by the suggestions and the '\n' symbols
string[] resultSeparated = result.FragmentedTranslation;
//You can get all text using MergedTranslation property
string resultMerged = result.MergedTranslation;
//There is also original text transcription
string transcription = result.TranslatedTextTranscription; // Kon'nichiwa! Ogenkidesuka?
Console.WriteLine(resultSeparated.Length);
//Console.WriteLine(result.SeeAlso.Length);
//Console.WriteLine(result.Synonyms.Conjunction.Length);
return(result.MergedTranslation);
}
public async Task <Result> Translate(string text, string to, string from = "en")
{
try
{
var fromLang = GoogleTranslator.GetLanguageByISO(from) ?? Language.Auto;;
var toLang = GoogleTranslator.GetLanguageByISO(to);
if (fromLang == null || toLang == null)
{
return(new Result(ErrorCode.LanguageNotRecognized));
}
var result = await _client.TranslateLiteAsync(text, fromLang, toLang);
return(new Result(result.MergedTranslation));
}
catch (HttpRequestException ex)
{
Console.WriteLine("Error: " + ex.Message);
if (ex.Message.Contains("429"))
{
return(new Result(ErrorCode.TooManyRequests));
}
return(new Result(ErrorCode.UnknownError));
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
return(new Result(ErrorCode.UnknownError));
}
}
private async void Translate()
{
if (LblEnglish.Text.Trim().Length >= 0)
{
BtnSave.IsEnabled = false;
BtnTranslate.IsEnabled = false;
var translator = new GoogleTranslator();
Language from = GoogleTranslateFreeApi.Language.English;
Language to = GoogleTranslateFreeApi.Language.Persian;
TranslationResult result = await translator.TranslateLiteAsync(LblEnglish.Text.Trim(), from, to);
//The result is separated by the suggestions and the '\n' symbols
string[] resultSeparated = result.FragmentedTranslation;
//You can get all text using MergedTranslation property
string resultMerged = result.MergedTranslation;
LblPersian.Text = resultMerged;
//There is also original text transcription
string transcription = result.TranslatedTextTranscription;
BtnSave.IsEnabled = true;
BtnTranslate.IsEnabled = true;
}
}
public NicoNicoServer(int PortNum, int ListenNum, int Translator = (int)Translators.User)
{
translator = Translator;
portNum = PortNum;
listenNum = ListenNum;
WriteConsole("NicoNicoTranslator " + ver, ConsoleColor.Green);
WriteConsole("오류 제보 : https://github.com/009342/Nico-Nico-Video-Translator/issues", ConsoleColor.DarkGreen);
WriteConsole("제작자 블로그 : http://sshbrain.tistory.com", ConsoleColor.DarkGreen);
WriteConsole("");
while (true)
{
if (translator == (int)Translators.User)
{
WriteConsole("사용할 번역 서비스를 선택해주세요.", ConsoleColor.Cyan);
WriteConsole("1. Google 번역");
WriteConsole("2. 파파고 번역");
WriteConsole("3. 사용하지 않음");
translator = int.Parse(Console.ReadLine());
}
if (translator == (int)Translators.Google || translator == (int)Translators.Papago || translator == (int)Translators.None)
{
break;
}
}
if (translator == (int)Translators.Google)
{
googleTranslator = new GoogleTranslator();
from = GoogleTranslator.GetLanguageByName("Japanese");
to = GoogleTranslator.GetLanguageByName("Korean");
}
if (translator == (int)Translators.Papago)
{
papagoTranslate = new PapagoTranslate();
}
}
public void InputChanged()
{
var propertyDefinitions = new StringBuilder();
var propertyAssignmentsForEN = new StringBuilder();
foreach (var trValue in Model.Input.Split(Environment.NewLine.ToCharArray()))
{
if (string.IsNullOrWhiteSpace(trValue))
{
continue;
}
var turkishText = trValue.Trim();
var english = TranslateTurkishToEnglish(turkishText);
var propertyName = GoogleTranslator.CreatePropertyNameFromSentence(english);
propertyDefinitions.AppendLine($"public string {propertyName} " + "{get;set;}");
propertyAssignmentsForEN.AppendLine(propertyName + "=" + '"' + english + '"' + ';');
}
Model.PropertyDefinition = propertyDefinitions.ToString();
Model.PropertyAssignmentForEN = propertyAssignmentsForEN.ToString();
}
private Func <CommandEventArgs, Task> ListLanguagesFunc() => async e =>
{
try
{
GoogleTranslator.EnsureInitialized();
string s = e.GetArg("search");
string ret = "";
foreach (string key in GoogleTranslator._languageModeMap.Keys)
{
if (!s.Equals(""))
{
if (key.ToLower().Contains(s))
{
ret += " " + key + ";";
}
}
else
{
ret += " " + key + ";";
}
}
await e.Channel.SendMessage(ret).ConfigureAwait(false);
}
catch
{
await e.Channel.SendMessage("Bad input format, or sth went wrong...").ConfigureAwait(false);
}
};
public async Task <TranslationResult> TranslateAsync(string text, string to)
{
var result = await Translator
.TranslateLiteAsync(text, Language.Auto, GoogleTranslator.GetLanguageByName(to))
.ConfigureAwait(false);
return(result);
}
public void TranslateText()
{
var s = "Hello, world!";
var ms = new GoogleTranslator("English", "Finnish");
var tl = ms.Translate(s);
Assert.AreEqual("Hei, maailma!", tl);
}
public async Task TranslateHelloWorld()
{
GoogleTranslator translator = new GoogleTranslator();
var translation = await translator.TranslateMessage("Hello World", "en", "fr");
Assert.AreEqual("Bonjour Le Monde", translation);
}
public MainModel(MainWindow mainWindow)
{
this.mainWindow = mainWindow;
wordsManager = WordsManager.Instance;
config = wordsManager.GetConfig();
RunTask();
GoogleTranslator googleTranslator = new GoogleTranslator();
}
private static void GoogleTranlsateAllNativeWordsToLang(GoogleTranslator googleTranslator, string to, List <string> CallTrace)
{
List <TSUIWordNative> listNatives = CosmosAPI.cosmosDBClientUIWordNative.GetAll(TodosCosmos.LocalFunctions.AddThisCaller(CallTrace, MethodBase.GetCurrentMethod())).Result;
foreach (var item in listNatives)
{
Console.WriteLine(item.Word + " - " + googleTranslator.Translate(item.Word, to));
}
}
public string Translate(string s, IMessage m, string targetLanguage = "English", string sourceLanguage = "")
{
Language from = string.IsNullOrWhiteSpace(sourceLanguage) ? Language.Auto : GoogleTranslator.GetLanguageByName(sourceLanguage);
Language to = GoogleTranslator.GetLanguageByName(targetLanguage);
TranslationResult result = translator.TranslateLiteAsync(s, from, to).Result;
return(result.MergedTranslation);
}
public async Task TranslateAsync_WithNoValidPhrase_ShouldTranslate()
{
HttpClient httpClient = new HttpClient();
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "");
}
public void Test_GoogleTranslator()
{
var translator = new GoogleTranslator();
var originalText = "想要成为";
var translatedText = translator.Translate(originalText, "zh", "en");
Assert.AreEqual(translatedText, "Want to be", true, "Not translating correctly.");
}
protected override void GetSupportedLanguages()
{
// Assume google vision can handle all google translate languages
GoogleTranslator translate = new GoogleTranslator();
foreach (KeyValuePair <string, string> language in translate.SupportedLanguages)
{
AddSupportedLanguage(language.Key, language.Value);
}
}
public async Task TranslateAsync_WithValidData_Translates()
{
var httpClient = new HttpClient();
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("ja", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "I");
}
public async Task TranslateAsync_NoHttpClient_ShouldTranslate()
{
HttpClient httpClient = null;
var translator = new GoogleTranslator(httpClient);
var returnedString = await translator.TranslateAsync("ja", "pl", "en");
Console.WriteLine(returnedString);
StringAssert.Contains(returnedString, "I");
}
public static async Task <TranslationResult> TranslateAsync(this string forTranslate, string toLang)
{
var translator = new GoogleTranslator();
var from = Language.Auto;
var to = GoogleTranslator.GetLanguageByISO(toLang);
var result = await translator.TranslateLiteAsync(forTranslate, from, to)
.ConfigureAwait(false);
return(result);
}
public void Translate()
{
var testObj = new GoogleTranslator();
var ret = testObj.Translate(@"There seems to be some controversy about the advantages of static vs.
dynamic and strong vs. weak typing. Let me illustrate these choices
with a thought experiment. Imagine millions of monkeys at computer
keyboards happily hitting random keys, producing programs, compiling,
and running them.", "en", "ko");
Debug.WriteLine(ret);
}
public async Task <string> Translate(string textToTranslate)
{
GoogleTranslator googleTranslator = new GoogleTranslator();
TranslationResult result = await googleTranslator.TranslateAsync(textToTranslate, Language.Auto, Language.English);
string translatedText = result.MergedTranslation;
SaveTranslation(textToTranslate, translatedText);
return(translatedText);
}
