public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonTranscribeServiceConfig config = new AmazonTranscribeServiceConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonTranscribeServiceClient client = new AmazonTranscribeServiceClient(creds, config);
ListTranscriptionJobsResponse resp = new ListTranscriptionJobsResponse();
do
{
ListTranscriptionJobsRequest req = new ListTranscriptionJobsRequest
{
NextToken = resp.NextToken
,
MaxResults = maxItems
};
resp = client.ListTranscriptionJobs(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.TranscriptionJobSummaries)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
//--- Methods ---
public override async Task InitializeAsync(LambdaConfig config)
{
_transcribe = new AmazonTranscribeServiceClient();
_outputBucketName = config.ReadS3BucketName("ExtractedTextBucket");
_notifyQueueUrl = config.ReadSqsQueueUrl("ProgressQueue");
_sqsClient = new AmazonSQSClient();
}
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.");
}
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-" + jobHelper.JobAssignmentId.Substring(jobHelper.JobAssignmentId.LastIndexOf("/") + 1),
LanguageCode = "en-US",
Media = new Media {
MediaFileUri = mediaFileUrl
},
MediaFormat = mediaFormat,
OutputBucketName = jobHelper.Request.GetRequiredContextVariable("ServiceOutputBucket")
};
using (var transcribeService = new AmazonTranscribeServiceClient())
await transcribeService.StartTranscriptionJobAsync(transcribeParameters);
}
//--- Methods ---
public override async Task InitializeAsync(LambdaConfig config)
{
_transcribe = new AmazonTranscribeServiceClient();
_table = new IndexingStatusTable(
config.ReadDynamoDBTableName("IndexingStatusTable"),
new AmazonDynamoDBClient()
);
}
//--Methods--
public override Task InitializeAsync(LambdaConfig config)
{
_rand = new Random();
_textBucket = new S3Bucket(config.ReadText("TextForPolly"));
_audioBucket = new S3Bucket(config.ReadText("AudioForTranscribe"));
_pollyClient = new AmazonPollyClient();
_transcribeClient = new AmazonTranscribeServiceClient();
return(Task.CompletedTask);
}
//--Methods--
public override Task InitializeAsync(LambdaConfig config)
{
_audioBucket = AwsConverters.ConvertBucketArnToName(config.ReadText("AudioForTranscribe"));
_textBucket = AwsConverters.ConvertBucketArnToName(config.ReadText("TextForPolly"));
_topic = config.ReadText("Loop");
_rand = new Random();
_s3Client = new AmazonS3Client();
_pollyClient = new AmazonPollyClient();
_transcribeClient = new AmazonTranscribeServiceClient();
_snsClient = new AmazonSimpleNotificationServiceClient();
return(Task.CompletedTask);
}
protected IAmazonTranscribeService CreateClient(AWSCredentials credentials, RegionEndpoint region)
{
var config = new AmazonTranscribeServiceConfig {
RegionEndpoint = region
};
Amazon.PowerShell.Utils.Common.PopulateConfig(this, config);
this.CustomizeClientConfig(config);
var client = new AmazonTranscribeServiceClient(credentials, config);
client.BeforeRequestEvent += RequestEventHandler;
client.AfterResponseEvent += ResponseEventHandler;
return(client);
}
internal static ISpeechServiceStrategy CreateService(SpeechServiceType type)
{
switch (type)
{
case SpeechServiceType.aws:
string accessKey;
string secretAccessKey;
string regionEndpointName;
if (ConfigurationManager.GetSection("awsConfig") is NameValueCollection awsSettings)
{
accessKey = awsSettings["accessKey"];
secretAccessKey = awsSettings["secretAccessKey"];
regionEndpointName = awsSettings["region"];
}
else
{
throw new InvalidCredentialException();
}
var s3Client = new AmazonS3Client(accessKey, secretAccessKey, RegionEndpoint.GetBySystemName(regionEndpointName));
var atClient = new AmazonTranscribeServiceClient(accessKey, secretAccessKey, RegionEndpoint.GetBySystemName(regionEndpointName));
var awsBucketName = Guid.NewGuid().ToString();
return(new Aws(s3Client, atClient, awsBucketName));
case SpeechServiceType.google:
string credentialPath;
string projectId;
if (ConfigurationManager.GetSection("googleConfig") is NameValueCollection googleSettings)
{
credentialPath = googleSettings["pathToCredentialsFile"];
projectId = googleSettings["projectId"];
if (Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS") == null)
{
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", credentialPath);
}
}
else
{
throw new InvalidCredentialException();
}
var googleClient = StorageClient.Create();
var googBucketName = Guid.NewGuid().ToString();
return(new Goog(googleClient, googBucketName, projectId));
case SpeechServiceType.ibm:
string username;
string password;
if (ConfigurationManager.GetSection("ibmConfig") is NameValueCollection ibmSettings)
{
username = ibmSettings["username"];
password = ibmSettings["password"];
}
else
{
throw new InvalidCredentialException();
}
var authBytes = Encoding.UTF8.GetBytes(username + ":" + password);
var base64EncryptedCredentials = Convert.ToBase64String(authBytes);
var ibmClient = new HttpClient();
ibmClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", base64EncryptedCredentials);
return(new Ibm(ibmClient));
case SpeechServiceType.azure:
string apiKey;
string apiRegion;
if (ConfigurationManager.GetSection("azureConfig") is NameValueCollection azureSettings)
{
apiKey = azureSettings["subscriptionKey"];
apiRegion = azureSettings["region"];
}
else
{
throw new InvalidCredentialException();
}
return(new Azure(apiKey, apiRegion));
case SpeechServiceType.azureAdv:
string subscriptionKey;
string accountId;
string location;
if (ConfigurationManager.GetSection("azureAdvanced") is NameValueCollection azureAdvSettings)
{
subscriptionKey = azureAdvSettings["subscriptionKey"];
accountId = azureAdvSettings["accountId"];
location = azureAdvSettings["location"];
}
else
{
throw new InvalidCredentialException();
}
return(new AzureAdvanced(subscriptionKey, accountId, location));
default:
throw new NotSupportedException();
}
}
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 string GetTranscriptURL()
{
string result = string.Empty;
try
{
AmazonTranscribeServiceClient client = new AmazonTranscribeServiceClient(ConfigurationManager.AppSettings["AmazonAccessKey"],
ConfigurationManager.AppSettings["AmazonSecretAccessKey"],
RegionEndpoint.EUWest1);
if (client != null)
{
string url = String.Format(ConfigurationManager.AppSettings["AmazonBucketURL"],
ConfigurationManager.AppSettings["AmazonBucketName"],
keyName);
Media media = new Media();
StartTranscriptionJobResponse transcriptionJobResponse = null;
GetTranscriptionJobResponse checkJob = null;
media.MediaFileUri = url;
StartTranscriptionJobRequest transcriptionJobRequest = new StartTranscriptionJobRequest();
string name = Guid.NewGuid().ToString();
transcriptionJobRequest.TranscriptionJobName = name;
transcriptionJobRequest.MediaFormat = "wav";
transcriptionJobRequest.Media = media;
transcriptionJobRequest.LanguageCode = "en-US";
GetTranscriptionJobRequest getTranscriptionJobRequest = new GetTranscriptionJobRequest();
getTranscriptionJobRequest.TranscriptionJobName = name;
bool finished = false;
transcriptionJobResponse = client.StartTranscriptionJob(transcriptionJobRequest);
while (!finished)
{
checkJob = client.GetTranscriptionJob(getTranscriptionJobRequest);
if (checkJob != null)
{
if (!checkJob.TranscriptionJob.TranscriptionJobStatus.Value.Contains("IN_PROGRESS"))
{
finished = true;
}
Thread.Sleep(1000);
}
}
result = checkJob.TranscriptionJob.Transcript.TranscriptFileUri;
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(result);
}
public Function()
{
transClient = new AmazonTranscribeServiceClient();
S3Client = new AmazonS3Client();
}
private async void BeginTranscription_Click(object sender, RoutedEventArgs e)
{
this._ctlBeginTranscription.IsEnabled = false;
try
{
this._ctlStatusLog.Text = "";
this._ctlTranscription.Text = "";
var filepath = this._ctlFilepath.Text;
if (string.IsNullOrEmpty(filepath))
{
MessageBox.Show($"An mp4 file must be selected first before transcribing", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (!System.IO.File.Exists(filepath))
{
MessageBox.Show($"File {filepath} does not exist", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var s3Key = System.IO.Path.GetFileName(filepath);
var s3Bucket = _ctlS3Bucket.Text;
var chain = new CredentialProfileStoreChain();
AWSCredentials credentials;
if (!chain.TryGetAWSCredentials(this._ctlProfile.Text, out credentials))
{
MessageBox.Show($"Profile {this._ctlProfile.Text} was not found", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var region = RegionEndpoint.GetBySystemName(this._ctlRegion.Text);
var transcriptionJobName = $"{s3Key}-{Guid.NewGuid().ToString()}";
using (var s3Client = new AmazonS3Client(credentials, region))
using (var transcribeClient = new AmazonTranscribeServiceClient(credentials, region))
using (var httpClient = new HttpClient()) // Http Client to download the transcription once complete
{
AppendStatusLine("Ensuring S3 bucket exists");
await s3Client.PutBucketAsync(s3Bucket);
var transferUtility = new TransferUtility(s3Client);
AppendStatusLine("Starting upload");
var uploadRequest = new TransferUtilityUploadRequest
{
FilePath = filepath,
BucketName = s3Bucket,
Key = s3Key
};
uploadRequest.UploadProgressEvent += ProgressUploadStatus;
await transferUtility.UploadAsync(uploadRequest);
var mediaFileUri = $"https://s3.{region.SystemName}.amazonaws.com/{s3Bucket}/{s3Key}";
AppendStatusLine($"Upload Complete to: {mediaFileUri}");
await transcribeClient.StartTranscriptionJobAsync(new StartTranscriptionJobRequest
{
LanguageCode = LanguageCode.EnUS,
Media = new Media
{
MediaFileUri = mediaFileUri
},
MediaFormat = MediaFormat.Mp4,
TranscriptionJobName = transcriptionJobName
});
AppendStatusLine($"Started transcription job: {transcriptionJobName}");
GetTranscriptionJobRequest request = new GetTranscriptionJobRequest {
TranscriptionJobName = transcriptionJobName
};
GetTranscriptionJobResponse response = null;
do
{
AppendStatusLine($"... {DateTime.Now} Waiting for transcription job to complete");
await Task.Delay(TimeSpan.FromSeconds(2));
response = await transcribeClient.GetTranscriptionJobAsync(request);
} while (response.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.IN_PROGRESS);
if (response.TranscriptionJob.TranscriptionJobStatus == TranscriptionJobStatus.FAILED)
{
AppendStatusLine($"Transcription job failed: {response.TranscriptionJob.FailureReason}");
return;
}
AppendStatusLine("Job Done");
var transcriptionDocument = await httpClient.GetStringAsync(response.TranscriptionJob.Transcript.TranscriptFileUri);
var root = JsonConvert.DeserializeObject(transcriptionDocument) as JObject;
var sb = new StringBuilder();
foreach (JObject transcriptionNode in root["results"]["transcripts"])
{
if (sb.Length != 0)
{
sb.AppendLine("\n\n");
}
sb.Append(transcriptionNode["transcript"]);
}
this._ctlTranscription.Text = sb.ToString();
}
}
catch (Exception ex)
{
AppendStatusLine($"Unknown error: {ex.Message}");
}
finally
{
this._ctlBeginTranscription.IsEnabled = true;
}
}
