static async Task Main(string[] args)
{
Console.WriteLine("Generate translation files using AWS Translate from Blazor I18nText JSON");
Console.Write("Enter File Path to English JSON: ");
var file = Console.ReadLine();
Console.Write("Enter list of languages to translate (comma separated): ");
var languages = Console.ReadLine().Split(',');
var dir = Path.GetDirectoryName(file);
var data = JsonConvert.DeserializeObject <Dictionary <string, string> >(File.ReadAllText(file));
using (var trans = new AmazonTranslateClient())
{
foreach (var lang in languages)
{
var newData = new Dictionary <string, string>();
foreach (var item in data)
{
var translation = await trans.TranslateTextAsync(new Amazon.Translate.Model.TranslateTextRequest()
{
SourceLanguageCode = "en",
TargetLanguageCode = lang,
Text = item.Value
});
if (translation.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
newData.Add(item.Key, translation.TranslatedText);
}
else
{
newData.Add(item.Key, "NO TRANSLATION");
}
//TODO: Error
}
var fn = Path.GetFileName(file).Split('.');
var newFn = $"{fn[0]}.{lang}.{fn[2]}";
var newFnPath = Path.Combine(dir, newFn);
Console.WriteLine(newFnPath);
if (!File.Exists(newFnPath))
{
File.Create(newFnPath).Dispose();
}
using (var fs = new FileStream(newFnPath, FileMode.Truncate))
{
var newJson = JsonConvert.SerializeObject(newData, new JsonSerializerSettings()
{
Formatting = Formatting.Indented,
});
using (var sr = new StreamWriter(fs, System.Text.Encoding.UTF8))
await sr.WriteAsync(newJson);
}
}
}
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
/// to respond to S3 notifications.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
{
var s3Event = evnt.Records?[0].S3;
if (s3Event == null)
{
return(null);
}
try
{
String content;
using (var s3Client = new AmazonS3Client())
{
GetObjectRequest request = new GetObjectRequest
{
BucketName = evnt.Records.First().S3.Bucket.Name,
Key = evnt.Records.First().S3.Object.Key
};
GetObjectResponse response = await s3Client.GetObjectAsync(request);
StreamReader reader = new StreamReader(response.ResponseStream);
content = reader.ReadToEnd();
using (var translateClient = new AmazonTranslateClient(Amazon.RegionEndpoint.EUWest1))
{
foreach (string language in languages)
{
var translateTextResponse = await translateClient.TranslateTextAsync(
new TranslateTextRequest()
{
Text = content,
SourceLanguageCode = "EN",
TargetLanguageCode = language
});
await S3Client.PutObjectAsync(new PutObjectRequest()
{
ContentBody = translateTextResponse.TranslatedText,
BucketName = evnt.Records.First().S3.Bucket.Name,
Key = evnt.Records.First().S3.Object.Key.Replace("EN", language)
});
}
}
return("Complete");
}
}
catch (Exception e)
{
context.Logger.LogLine(e.Message);
context.Logger.LogLine(e.StackTrace);
throw;
}
}
/// <summary>
/// Use the Amazon Translate Service to translate the document from the
/// source language to the specified destination language.
/// </summary>
/// <param name="client">The Amazon Translate Service client used to
/// perform the translation.</param>
/// <param name="srcLang">The language of the source text.</param>
/// <param name="destLang">The destination language for the translated
/// text.</param>
/// <param name="text">A string representing the text to ranslate.</param>
/// <returns>The text that has been translated to the destination
/// language.</returns>
public static async Task <string> TranslatingTextAsync(AmazonTranslateClient client, string srcLang, string destLang, string text)
{
var request = new TranslateTextRequest
{
SourceLanguageCode = srcLang,
TargetLanguageCode = destLang,
Text = text,
};
var response = await client.TranslateTextAsync(request);
return(response.TranslatedText);
}
private string TranslateBody(string msg, string lan)
{
var translateClient = new AmazonTranslateClient(RegionEndpoint.USEast2);
var request = new TranslateTextRequest
{
SourceLanguageCode = "en",
TargetLanguageCode = lan,
Text = msg,
};
var response = translateClient.TranslateTextAsync(request);
return(response.Result.TranslatedText);
}
static async Task Main()
{
var region = RegionEndpoint.APNortheast1;
var client = new AmazonTranslateClient(region);
var request = new TranslateTextRequest
{
SourceLanguageCode = "ja",
TargetLanguageCode = "en",
Text = "おはようございます"
};
var resp = await client.TranslateTextAsync(request);
var result = resp.TranslatedText;
Console.WriteLine(result);
}
public static async Task Translate(string text, string sourceLangaugeCode = "en",
string targetLangaugeCode = "de")
{
//Generate the client, Note: The config is used from your initital CLI configuration
var translate = new AmazonTranslateClient();
//Build up request
var request = new TranslateTextRequest
{
Text = text, SourceLanguageCode = sourceLangaugeCode, TargetLanguageCode = targetLangaugeCode
};
//Call translate service
var translation = await translate.TranslateTextAsync(request);
Console.WriteLine(translation.TranslatedText);
}
public ActionResult TranslateComment(TranslateCommentViewModel comment)
{
var translate = new AmazonTranslateClient("AKIAX3JSZJ36DOCUNIJY", "vTKVVvQs01qY25LczK5uSdD3gev49cdXfKNr7LRT", RegionEndpoint.USEast1);
var request = new TranslateTextRequest()
{
Text = comment.CommentText, SourceLanguageCode = "en", TargetLanguageCode = comment.TargetLanguage
};
var task = translate.TranslateTextAsync(request); //.TranslateText(request) // Make the actual call to Amazon Translate
task.Wait();
var model = new TranslatedCommentViewModel()
{
CommentText = comment.CommentText,
SubmitterName = comment.SubmitterName,
TargetLangauge = comment.TargetLanguage,
TranslateResponse = task.Result
};
return(View(model));
}
public async Task <JsonResult> Post(string translateText, string inputLanguage, string outputLanguage)
{
try
{
using (var translateClient = new AmazonTranslateClient())
{
var translateTextResponse = await translateClient.TranslateTextAsync(
new Amazon.Translate.Model.TranslateTextRequest()
{
Text = translateText,
SourceLanguageCode = inputLanguage,
TargetLanguageCode = outputLanguage
});
return(new JsonResult(translateTextResponse.HttpStatusCode == System.Net.HttpStatusCode.OK ?
translateTextResponse.TranslatedText : "Error processing request"));
}
}
catch (Exception ex)
{
return(new JsonResult(ex.Message));
}
}
internal static async Task ProcessJobAssignmentAsync(AwsAiServiceWorkerRequest @event)
{
var resourceManager = @event.GetAwsV4ResourceManager();
var table = new DynamoDbTable(@event.StageVariables["TableName"]);
var jobAssignmentId = @event.JobAssignmentId;
try
{
// 1. Setting job assignment status to RUNNING
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "RUNNING", null);
// 2. Retrieving WorkflowJob
var job = await RetrieveJobAsync(resourceManager, table, jobAssignmentId);
// 3. Retrieve JobProfile
var jobProfile = await RetrieveJobProfileAsync(resourceManager, job);
// 4. Retrieve job inputParameters
var jobInput = job.JobInput;
// 5. Check if we support jobProfile and if we have required parameters in jobInput
ValidateJobProfile(jobProfile, jobInput);
S3Locator inputFile;
if (!jobInput.TryGet <S3Locator>(nameof(inputFile), out inputFile))
{
throw new Exception("Invalid or missing input file.");
}
S3Locator outputLocation;
if (!jobInput.TryGet <S3Locator>(nameof(outputLocation), out outputLocation))
{
throw new Exception("Invalid or missing output location.");
}
switch (jobProfile.Name)
{
case JOB_PROFILE_TRANSCRIBE_AUDIO:
string mediaFileUrl;
if (!string.IsNullOrWhiteSpace(inputFile.HttpEndpoint))
{
mediaFileUrl = inputFile.HttpEndpoint;
}
else
{
var bucketLocation = await inputFile.GetBucketLocationAsync();
var s3SubDomain = !string.IsNullOrWhiteSpace(bucketLocation) ? $"s3-{bucketLocation}" : "s3";
mediaFileUrl = $"https://{s3SubDomain}.amazonaws.com/{inputFile.AwsS3Bucket}/{inputFile.AwsS3Key}";
}
string mediaFormat;
if (mediaFileUrl.EndsWith("mp3", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp3";
}
else if (mediaFileUrl.EndsWith("mp4", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "mp4";
}
else if (mediaFileUrl.EndsWith("wav", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "wav";
}
else if (mediaFileUrl.EndsWith("flac", StringComparison.OrdinalIgnoreCase))
{
mediaFormat = "flac";
}
else
{
throw new Exception($"Unable to determine media format from input file '{mediaFileUrl}'");
}
var transcribeParameters = new StartTranscriptionJobRequest
{
TranscriptionJobName = "TranscriptionJob-" + jobAssignmentId.Substring(jobAssignmentId.LastIndexOf("/") + 1),
LanguageCode = "en-US",
Media = new Media {
MediaFileUri = mediaFileUrl
},
MediaFormat = mediaFormat,
OutputBucketName = @event.StageVariables["ServiceOutputBucket"]
};
var transcribeService = new AmazonTranscribeServiceClient();
var startJobResponse = await transcribeService.StartTranscriptionJobAsync(transcribeParameters);
Logger.Debug(startJobResponse.ToMcmaJson().ToString());
break;
case JOB_PROFILE_TRANSLATE_TEXT:
var s3Bucket = inputFile.AwsS3Bucket;
var s3Key = inputFile.AwsS3Key;
GetObjectResponse s3Object;
try
{
s3Object = await inputFile.GetAsync();
}
catch (Exception error)
{
throw new Exception($"Unable to read file in bucket '{s3Bucket}' with key '{s3Key}'.", error);
}
var inputText = await new StreamReader(s3Object.ResponseStream).ReadToEndAsync();
var translateParameters = new TranslateTextRequest
{
SourceLanguageCode = jobInput.TryGet("sourceLanguageCode", out string srcLanguageCode) ? srcLanguageCode : "auto",
TargetLanguageCode = jobInput.Get <string>("targetLanguageCode"),
Text = inputText
};
var translateService = new AmazonTranslateClient();
var translateResponse = await translateService.TranslateTextAsync(translateParameters);
var s3Params = new PutObjectRequest
{
BucketName = outputLocation.AwsS3Bucket,
Key = (!string.IsNullOrWhiteSpace(outputLocation.AwsS3KeyPrefix) ? outputLocation.AwsS3Key : string.Empty) + Guid.NewGuid() + ".txt",
ContentBody = translateResponse.TranslatedText
};
var outputS3 = await outputLocation.GetClientAsync();
await outputS3.PutObjectAsync(s3Params);
var jobOutput = new JobParameterBag();
jobOutput["outputFile"] = new S3Locator
{
AwsS3Bucket = s3Params.BucketName,
AwsS3Key = s3Params.Key
};
Logger.Debug("Updating job assignment");
await UpdateJobAssignmentWithOutputAsync(table, jobAssignmentId, jobOutput);
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "COMPLETED");
break;
case JOB_PROFILE_DETECT_CELEBRITIES:
var randomBytes = new byte[16];
new Random().NextBytes(randomBytes);
var clientToken = randomBytes.HexEncode();
var base64JobId = Encoding.UTF8.GetBytes(jobAssignmentId).HexEncode();
var rekoParams = new StartCelebrityRecognitionRequest
{
Video = new Video
{
S3Object = new Amazon.Rekognition.Model.S3Object
{
Bucket = inputFile.AwsS3Bucket,
Name = inputFile.AwsS3Key
}
},
ClientRequestToken = clientToken,
JobTag = base64JobId,
NotificationChannel = new NotificationChannel
{
RoleArn = REKO_SNS_ROLE_ARN,
SNSTopicArn = SNS_TOPIC_ARN
}
};
var rekognitionClient = new AmazonRekognitionClient();
var startCelebRecognitionResponse = await rekognitionClient.StartCelebrityRecognitionAsync(rekoParams);
Logger.Debug(startCelebRecognitionResponse.ToMcmaJson().ToString());
break;
}
}
catch (Exception ex)
{
Logger.Exception(ex);
try
{
await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "FAILED", ex.ToString());
}
catch (Exception innerEx)
{
Logger.Exception(innerEx);
}
}
}
public async Task ExecuteAsync(WorkerJobHelper <AIJob> jobHelper)
{
S3Locator inputFile;
if (!jobHelper.JobInput.TryGet <S3Locator>(nameof(inputFile), out inputFile))
{
throw new Exception("Invalid or missing input file.");
}
S3Locator outputLocation;
if (!jobHelper.JobInput.TryGet <S3Locator>(nameof(outputLocation), out outputLocation))
{
throw new Exception("Invalid or missing output location.");
}
var s3Bucket = inputFile.AwsS3Bucket;
var s3Key = inputFile.AwsS3Key;
GetObjectResponse s3Object;
try
{
s3Object = await inputFile.GetAsync();
}
catch (Exception error)
{
throw new Exception($"Unable to read file in bucket '{s3Bucket}' with key '{s3Key}'.", error);
}
var inputText = await new StreamReader(s3Object.ResponseStream).ReadToEndAsync();
var translateParameters = new TranslateTextRequest
{
SourceLanguageCode = jobHelper.JobInput.TryGet("sourceLanguageCode", out string srcLanguageCode) ? srcLanguageCode : "auto",
TargetLanguageCode = jobHelper.JobInput.Get <string>("targetLanguageCode"),
Text = inputText
};
var translateService = new AmazonTranslateClient();
var translateResponse = await translateService.TranslateTextAsync(translateParameters);
var s3Params = new PutObjectRequest
{
BucketName = outputLocation.AwsS3Bucket,
Key = (!string.IsNullOrWhiteSpace(outputLocation.AwsS3KeyPrefix) ? outputLocation.AwsS3Key : string.Empty) + Guid.NewGuid() + ".txt",
ContentBody = translateResponse.TranslatedText
};
var outputS3 = await outputLocation.GetClientAsync();
await outputS3.PutObjectAsync(s3Params);
jobHelper.JobOutput.Set("outputFile", new S3Locator
{
AwsS3Bucket = s3Params.BucketName,
AwsS3Key = s3Params.Key
});
await jobHelper.CompleteAsync();
}
}