public async Task <(bool Success, string?Message)> Execute(Stream input, string blobName, string outputBlobName) { // Validate max width of the image using (Image image = Image.Load(input)) { if (image.Width > _settings.MaxMediaSize) { return(false, $"Image is too big. Requesting resize."); } } var blockBlob = Helpers.BlobHelper.GetBlobReference(outputBlobName) ?? throw new ArgumentException($"Blob '{blobName}' not found"); input.Position = 0; // Get smart thumbnail var credentials = new ApiKeyServiceClientCredentials(_settings.CognitiveServices.Key); using (var visionClient = new ComputerVisionClient(credentials) { Endpoint = _settings.CognitiveServices.Endpoint }) using (var result = await visionClient.GenerateThumbnailInStreamAsync(_settings.ThumbnailSize, _settings.ThumbnailSize, input, true)) using (var output = new MemoryStream()) { await result.CopyToAsync(output); output.Position = 0; await blockBlob.UploadFromStreamAsync(output); } return(true, null); }
public static async Task Main() { string text = "SQLSaturday is Awesome!"; string[] endpoints = new string[] { "<endpointGoesHere>", "http://localhost:5000" }; string key = "<apiKeyGoesHere>"; ApiKeyServiceClientCredentials credentials = new ApiKeyServiceClientCredentials(key); foreach (string endpoint in endpoints) { using (TextAnalyticsClient client = new TextAnalyticsClient(credentials) { Endpoint = endpoint }) { SentimentResult sentiment = await client.SentimentAsync(text); Console.WriteLine($"Sentiment for text: '{text}'\n On endpoint: '{endpoint}'\n is: {sentiment.Score}\n"); } } Console.ReadLine(); }
public AzureHelper(string subscriptionKey, string apiEndpoint) { ApiKeyServiceClientCredentials Credentials = new ApiKeyServiceClientCredentials(subscriptionKey); client = new ComputerVisionClient(Credentials); client.Endpoint = apiEndpoint; }
static async Task <LuisResult> GetPrediction() { // Use Language Understanding or Cognitive Services key // to create authentication credentials var endpointPredictionkey = "<REPLACE-WITH-YOUR-KEY>"; var credentials = new ApiKeyServiceClientCredentials(endpointPredictionkey); // Create Luis client and set endpoint // region of endpoint must match key's region var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }); luisClient.Endpoint = "https://<REPLACE-WITH-YOUR-KEY-REGION>.api.cognitive.microsoft.com"; // Set query values // public Language Understanding Home Automation app var appId = "df67dcdb-c37d-46af-88e1-8b97951ca1c2"; // query specific to home automation app var query = "turn on the bedroom light"; // common settings for remaining parameters Double?timezoneOffset = null; var verbose = true; var staging = false; var spellCheck = false; String bingSpellCheckKey = null; var log = false; // Create prediction client var prediction = new Prediction(luisClient); // get prediction return(await prediction.ResolveAsync(appId, query, timezoneOffset, verbose, staging, spellCheck, bingSpellCheckKey, log, CancellationToken.None)); }
static async Task <LuisResult> GetPrediction() { var endpointPredictionkey = "5cfeca8bb6734baf81b8c65f71635515"; var credentials = new ApiKeyServiceClientCredentials(endpointPredictionkey); var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }); luisClient.Endpoint = "https://westus.api.cognitive.microsoft.com"; // public Language Understanding Home Automation app var appId = "344b9f85-5975-4edc-9e66-56cdc7013b9a"; // query specific to home automation app var query = "probando"; // common settings for remaining parameters Double?timezoneOffset = 0; var verbose = true; var staging = true; var spellCheck = false; String bingSpellCheckKey = null; var log = true; // Create prediction client var prediction = new Prediction(luisClient); // get prediction return(await prediction.ResolveAsync(appId, query, timezoneOffset, verbose, staging, spellCheck, bingSpellCheckKey, log, CancellationToken.None)); }
private async Task <LuisResult> GetPrediction(String message) { var endpointPredictionkey = _config.GetSection("LuisConfig:endpointPredictionkey").Value; var credentials = new ApiKeyServiceClientCredentials(endpointPredictionkey); var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }); luisClient.Endpoint = _config.GetSection("LuisConfig:Endpoint").Value; // public Language Understanding Home Automation app var appId = _config.GetSection("LuisConfig:appId").Value; // query specific to home automation app var query = message; // common settings for remaining parameters Double?timezoneOffset = _config.GetSection("LuisConfig").GetValue <int>("timezoneOffset"); var verbose = _config.GetSection("LuisConfig").GetValue <bool>("verbose"); var staging = _config.GetSection("LuisConfig").GetValue <bool>("staging"); var spellCheck = _config.GetSection("LuisConfig").GetValue <bool>("spellCheck"); var bingSpellCheckKey = _config.GetSection("LuisConfig:bingSpellCheckKey").Value; var log = _config.GetSection("LuisConfig").GetValue <bool>("log"); // Create prediction client var prediction = new Prediction(luisClient); // get prediction return(await prediction.ResolveAsync(appId, query, timezoneOffset, verbose, staging, spellCheck, bingSpellCheckKey, log, CancellationToken.None)); }
public async Task RunAsync(string endpoint, string key, string text) { var credentials = new ApiKeyServiceClientCredentials(key); var client = new TextAnalyticsClient(credentials) { Endpoint = endpoint }; // The documents to be submitted for entity recognition. The ID can be any value. var inputDocuments = new MultiLanguageBatchInput( new List <MultiLanguageInput> { new MultiLanguageInput("en", "1", text) }); var entitiesResult = await client.EntitiesAsync(false, inputDocuments); // Printing recognized entities foreach (var document in entitiesResult.Documents) { foreach (var entity in document.Entities) { Entity.Add($"{entity.Name}[{entity.Type ?? "N/A"}]"); //Console.WriteLine($"\t\tName: {entity.Name},\tType: {entity.Type ?? "N/A"},\tSub-Type: {entity.SubType ?? "N/A"}"); //foreach (var match in entity.Matches) //{ // Console.WriteLine($"\t\t\tOffset: {match.Offset},\tLength: {match.Length},\tScore: {match.EntityTypeScore:F3}"); //} } } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req, ILogger log) { var apiKeys = new ApiKeyServiceClientCredentials(Environment.GetEnvironmentVariable("NewsSearchApiKey")); var newsClient = new NewsSearchClient(apiKeys) { Endpoint = Environment.GetEnvironmentVariable("NewsSearchUrl") }; var returnArticles = new List <PartlyNewsy.Models.Article>(); var news = await newsClient.News.SearchAsync(query : ""); foreach (var item in news.Value) { var article = new PartlyNewsy.Models.Article { ArticleUrl = item.Url, Category = item.Category, DatePublished = DateTime.Parse(item.DatePublished), FeaturedImage = item.Image.Thumbnail.ContentUrl, Headline = item.Name, NewsProviderImageUrl = item.Provider.First().Image.Thumbnail.ContentUrl, NewsProviderName = item.Provider.First().Name }; returnArticles.Add(article); } return(new OkObjectResult(returnArticles)); }
protected BingImageSearchService() { const string subscriptionKey = "70c508d2c10147f79d9d260042ade225"; var credentials = new ApiKeyServiceClientCredentials(subscriptionKey); _client = new ImageSearchClient(credentials); }
private async Task <LuisResult> LuisRequest(string query) { var endpointPredictionkey = "YOUR_KEY"; var credentials = new ApiKeyServiceClientCredentials(endpointPredictionkey); var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }); luisClient.Endpoint = "https://westus.api.cognitive.microsoft.com/"; // public Language Understanding Home Automation app var appId = "YOUR_APP_ID"; // query specific to home automation app // common settings for remaining parameters Double?timezoneOffset = null; var verbose = true; var staging = false; var spellCheck = false; String bingSpellCheckKey = null; var log = false; // Create prediction client var prediction = new Prediction(luisClient); // get prediction return(await prediction.ResolveAsync(appId, query, timezoneOffset, verbose, staging, spellCheck, bingSpellCheckKey, log, CancellationToken.None)); }
private PredictionResponse GetPrediction(string utterance) { var language = GuessLanguage(utterance); var appId = GetAppId(language); var credentials = new ApiKeyServiceClientCredentials(Config.PredictionKey); using (var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }) { Endpoint = Config.Endpoint }) { var requestOptions = new PredictionRequestOptions { DatetimeReference = DateTime.Now, //DateTime.Parse("2019-01-01"), PreferExternalEntities = true }; var predictionRequest = new PredictionRequest { Query = utterance, Options = requestOptions }; // get prediction return(luisClient.Prediction.GetSlotPredictionAsync( Guid.Parse(appId), slotName: "staging", predictionRequest, verbose: true, showAllIntents: true, log: true).Result); } }
public async Task <TextAnalyticsAnalyzeResponse> Analyze(string text, string languageHint) { var credentials = new ApiKeyServiceClientCredentials(_subscriptionKey); var client = new TextAnalyticsClient(credentials) { Endpoint = _endpoint }; var detectedLanguageResult = await client.DetectLanguageAsync(text, languageHint, true); if (string.IsNullOrWhiteSpace(languageHint)) { languageHint = detectedLanguageResult.DetectedLanguages.FirstOrDefault()?.Iso6391Name ?? ""; } var entitiesResult = client.EntitiesAsync(text, languageHint, true); var keyPhrasesResult = client.KeyPhrasesAsync(text, languageHint, true); var sentimentResult = client.SentimentAsync(text, languageHint, true); await Task.WhenAll(entitiesResult, keyPhrasesResult, sentimentResult); return(new TextAnalyticsAnalyzeResponse { DetectedLanguage = detectedLanguageResult, KeyPhrases = keyPhrasesResult.Result, Sentiment = sentimentResult.Result, Entities = entitiesResult.Result }); }
/// <summary> /// Sends a URL to Cognitive Services and performs analysis. /// </summary> /// <param name="imageUrl">The URL of the image to analyze.</param> /// <returns>Awaitable image analysis result.</returns> private async Task <string> AnalyzeUrlAsync(string imageUrl, ITurnContext <IMessageActivity> turnContext, CancellationToken cancellationToken) { string key = "<SERVICE CLIENT KEY>"; var test = new ApiKeyServiceClientCredentials(key); using (var client = new ComputerVisionClient(test) { Endpoint = "https://colourfind.cognitiveservices.azure.com/" }) { VisualFeatureTypes[] visualFeatures = new List <VisualFeatureTypes>() { VisualFeatureTypes.Color, VisualFeatureTypes.Description, VisualFeatureTypes.Tags }.ToArray(); string language = "en"; ImageAnalysis analysisResult; analysisResult = await client.AnalyzeImageAsync(imageUrl, visualFeatures, null, language); string mainColour = analysisResult.Color.DominantColorForeground; return(mainColour); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.Configure <CookiePolicyOptions>(options => { // This lambda determines whether user consent for non-essential cookies is needed for a given request. options.CheckConsentNeeded = context => true; options.MinimumSameSitePolicy = SameSiteMode.None; }); services.AddMvc(); services.AddDbContext <HotelsContext>(options => options.UseSqlServer(GetConnectionString(), sqlServerOptionsAction: sqlOptions => { sqlOptions.EnableRetryOnFailure( maxRetryCount: 3, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null); })); services.AddScoped(factory => { var apiKey = Configuration["TextAnalyticsApiKey"]; var baseUrl = Configuration["TextAnalyticsBaseUrl"]; var credentials = new ApiKeyServiceClientCredentials(apiKey); return(new TextAnalyticsClient(credentials) { Endpoint = baseUrl }); }); services.AddScoped <TextAnalysisService>(); services.AddScoped <ReviewsService>(); }
public async Task <UserQuery> DetectIntent(string message, string sessionId) { var credentials = new ApiKeyServiceClientCredentials(PredictionSubscriptionKey); var runtimeClient = new LUISRuntimeClient(credentials) { Endpoint = PredictionEndpoint }; var request = new PredictionRequest { Query = message }; var response = await runtimeClient.Prediction.GetSlotPredictionAsync(Guid.Parse(AppId), SlotName, request); var prediction = response.Prediction; var isFallback = prediction.Intents.Values.Max(i => i.Score) < 0.6 || prediction.TopIntent == "None"; return(new UserQuery { IntentName = prediction.TopIntent, IsFallback = isFallback, Parameters = prediction.Entities.ToDictionary( entity => entity.Key, entity => entity.Value is Newtonsoft.Json.Linq.JArray arr ? string.Join(',', arr.Select(s => s.ToString())) : entity.Value), AllRequiredParamsPresent = true, FulfillmentText = isFallback ? FallbackMessage : null, Timestamp = DateTime.UtcNow.Ticks });
private static async void RecognizePrintedTextWithSdkAsync(string imagePath, bool detectOrientation) { ServiceClientCredentials serviceClientCredentials = new ApiKeyServiceClientCredentials(key); Microsoft.Azure.CognitiveServices.Vision.ComputerVision.ComputerVisionAPI computerVisionApi = new Microsoft.Azure.CognitiveServices.Vision.ComputerVision.ComputerVisionAPI( serviceClientCredentials) { AzureRegion = AzureRegions.Southcentralus }; HttpOperationResponse <OcrResult> result; using (FileStream fileReader = new FileStream(imagePath, FileMode.Open)) { result = await computerVisionApi.RecognizePrintedTextInStreamWithHttpMessagesAsync(detectOrientation, fileReader); } foreach (OcrRegion region in result.Body.Regions) { foreach (OcrLine line in region.Lines) { foreach (OcrWord word in line.Words) { Console.WriteLine(word.Text); } } } }
public async static Task <ImageAnalysis> DescribePicture(MediaFile photo) { ImageAnalysis description = null; try { if (photo != null) { using (var stream = photo.GetStream()) { var credentials = new ApiKeyServiceClientCredentials(Constants.VisionApiKey); var client = new System.Net.Http.DelegatingHandler[] { }; var visionClient = new ComputerVisionClient(credentials, client); visionClient.Endpoint = Constants.VisionEndpoint; var features = new VisualFeatureTypes[] { VisualFeatureTypes.Tags, VisualFeatureTypes.Faces, VisualFeatureTypes.Categories, VisualFeatureTypes.Description, VisualFeatureTypes.Color }; description = await visionClient.AnalyzeImageInStreamAsync(stream, features); } } } catch (Exception ex) { } return(description); }
public async Task RunAsync(string endpoint, string key, string text) { var credentials = new ApiKeyServiceClientCredentials(key); var client = new TextAnalyticsClient(credentials) { Endpoint = endpoint }; var inputDocuments = new MultiLanguageBatchInput( new List <MultiLanguageInput> { new MultiLanguageInput("en", "1", text) }); var kpResults = await client.KeyPhrasesAsync(false, inputDocuments); // Printing keyphrases foreach (var document in kpResults.Documents) { //Console.WriteLine($"Document ID: {document.Id} "); //Console.WriteLine("\t Key phrases:"); foreach (string keyphrase in document.KeyPhrases) { Phrase.Add($"{keyphrase}"); //Console.WriteLine($"\t\t{keyphrase}"); } } }
private static IServiceCollection AddInfrastructureClients(this IServiceCollection services, IConfiguration configuration) { services.AddScoped <IComputerVisionClient>(factory => { var key = configuration["COMPUTER_VISION_SUBSCRIPTION_KEY"]; var host = configuration["COMPUTER_VISION_ENDPOINT"]; var credentials = new ApiKeyServiceClientCredentials(key); var client = new ComputerVisionClient(credentials); client.Endpoint = host; return(client); }); services.AddHttpClient <IImageAnalysisClient, ImageAnalysisClient>() .AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(3, retryCount => TimeSpan.FromSeconds(Math.Pow(2, retryCount)))); services.AddHttpClient <IUkiyoApiClient, UkiyoApiClient>() .AddTransientHttpErrorPolicy(builder => builder.WaitAndRetryAsync(3, retryCount => TimeSpan.FromSeconds(Math.Pow(2, retryCount)))); services.Scan(scan => scan .FromAssemblyOf <ImageAnalysisClient>() .AddClasses(classes => classes.Where(c => c.Name.EndsWith("Service"))) .UsingRegistrationStrategy(RegistrationStrategy.Skip) .AsImplementedInterfaces() .WithScopedLifetime()); return(services); }
private static void ProcessKeyPhrases(string documentid, string text) { var credentials = new ApiKeyServiceClientCredentials("key here"); ITextAnalyticsAPI client = new TextAnalyticsAPI(new ApiKeyServiceClientCredentials("key here")); client.AzureRegion = AzureRegions.Westeurope; KeyPhraseBatchResult result2 = client.KeyPhrasesAsync(new MultiLanguageBatchInput( new List <MultiLanguageInput>() { new MultiLanguageInput("en", documentid + ":" + text, text) })).Result; foreach (var document in result2.Documents) { Console.WriteLine("Document ID: {0} ", document.Id); Console.WriteLine("\t Key phrases:"); foreach (string keyphrase in document.KeyPhrases) { Console.WriteLine("\t\t" + keyphrase); } } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddCors(); services.AddDbContext <AssetManagementSystemDBContext>(options => options.UseSqlServer("Server = localhost; Database = AssetManagementSystemDB; Trusted_Connection = True;")); /*Services */ services.AddScoped <IComputerVisionClient>(factory => { var key = Configuration["ComputerVisionKey"]; var host = Configuration["ComputerVisionEndpoint"]; var credentials = new ApiKeyServiceClientCredentials(key); var client = new ComputerVisionClient(credentials); client.Endpoint = host; return(client); }); services.AddScoped(x => { return(new BlobServiceClient(Configuration["AzureBlobStorage"])); }); services.AddOptions(); services.Configure <ConfigurationValues>(Configuration.GetSection("AppValue")); //Services services.AddScoped <IBlobService, BlobService>(); services.AddScoped <ICognitiveService, CognitiveService>(); services.AddScoped <IAssetService, AssetService>(); //Repositories services.AddScoped <IMetadataRepository, MetadataRepository>(); services.AddScoped <IImageVariantRepository, ImageVariantRepository>(); services.AddScoped <IAssetRepository, AssetRepository>(); }
/// <summary> /// Initializes a new instance of the <see cref="LuisRecognizer"/> class. /// </summary> /// <param name="application">The LUIS application to use to recognize text.</param> /// <param name="predictionOptions">(Optional) The LUIS prediction options to use.</param> /// <param name="includeApiResults">(Optional) TRUE to include raw LUIS API response.</param> /// <param name="clientHandler">(Optional) Custom handler for LUIS API calls to allow mocking.</param> public LuisRecognizer(LuisApplication application, LuisPredictionOptions predictionOptions = null, bool includeApiResults = false, HttpClientHandler clientHandler = null) { _application = application ?? throw new ArgumentNullException(nameof(application)); _options = predictionOptions ?? new LuisPredictionOptions(); _includeApiResults = includeApiResults; TelemetryClient = _options.TelemetryClient; LogPersonalInformation = _options.LogPersonalInformation; var credentials = new ApiKeyServiceClientCredentials(application.EndpointKey); var delegatingHandler = new LuisDelegatingHandler(); var httpClientHandler = clientHandler ?? CreateRootHandler(); var currentHandler = CreateHttpHandlerPipeline(httpClientHandler, delegatingHandler); DefaultHttpClient = new HttpClient(currentHandler, false) { Timeout = TimeSpan.FromMilliseconds(_options.Timeout), }; // assign DefaultHttpClient to _httpClient to expose Timeout in unit tests // and keep HttpClient usage as a singleton _httpClient = DefaultHttpClient; _runtime = new LUISRuntimeClient(credentials, _httpClient, false) { Endpoint = application.Endpoint, }; }
private static async Task <PredictionResponse> GetIntentAndEntities(string messageText) { var credentials = new ApiKeyServiceClientCredentials(_luisPredictionKey); var luisClient = new LUISRuntimeClient(credentials, new System.Net.Http.DelegatingHandler[] { }) { Endpoint = _luisBaseUrl }; var requestOptions = new PredictionRequestOptions { DatetimeReference = DateTime.Parse("2019-01-01"), PreferExternalEntities = true }; var predictionRequest = new PredictionRequest { Query = messageText, Options = requestOptions }; // get prediction return(await luisClient.Prediction.GetSlotPredictionAsync( Guid.Parse(_luisAppId), slotName : "production", predictionRequest, verbose : true, showAllIntents : true, log : true)); }
public override async Task <GetThumbnailResponse> GetThumbnail(GetThumbnailRequest request) { var response = new GetThumbnailResponse(); try { var apiKeyServiceClientCredentials = new ApiKeyServiceClientCredentials(request.EndPointKey1); var delegatingHandlers = new System.Net.Http.DelegatingHandler[] { }; IComputerVisionClient computerVision = new ComputerVisionClient( credentials: apiKeyServiceClientCredentials, handlers: delegatingHandlers) { Endpoint = request.EndPoint }; response.Thumbnail = await computerVision.GenerateThumbnailInStreamAsync( image : request.ImageStream, width : request.ThumbnailSize.Width, height : request.ThumbnailSize.Height, smartCropping : request.ThumbnailSize.SmartCropping); response.Success = true; } catch (Exception e) { response.FailureInformation = e.Message; } return(response); }
private async Task <TextOperationResult> RecognizeAsync <T>(Func <ComputerVisionClient, Task <T> > GetHeadersAsyncFunc, Func <T, string> GetOperationUrlFunc) where T : new() { // ----------------------------------------------------------------------- // KEY SAMPLE CODE STARTS HERE // ----------------------------------------------------------------------- var result = default(TextOperationResult); OutputWriterSB.AppendLine("Create result variable for storing result"); // // Create Cognitive Services Vision API Service client. // var Credentials = new ApiKeyServiceClientCredentials("d8358f4194c8447bbca7c9e1605f15b0"); var Endpoint = "https://sushmavisionapi.cognitiveservices.azure.com/"; using (var client = new ComputerVisionClient(Credentials) { Endpoint = Endpoint }) { Debug.WriteLine("ComputerVisionClient is created"); OutputWriterSB.AppendLine("ComputerVisionClient is created"); try { Debug.WriteLine("Calling ComputerVisionClient.RecognizeTextAsync()..."); OutputWriterSB.AppendLine("Calling ComputerVisionClient.RecognizeTextAsync()..."); T recognizeHeaders = await GetHeadersAsyncFunc(client); string operationUrl = GetOperationUrlFunc(recognizeHeaders); string operationId = operationUrl.Substring(operationUrl.LastIndexOf('/') + 1); Debug.WriteLine("Calling ComputerVisionClient.GetTextOperationResultAsync()..."); OutputWriterSB.AppendLine("Calling ComputerVisionClient.GetTextOperationResultAsync()..."); result = await client.GetTextOperationResultAsync(operationId); for (int attempt = 1; attempt <= 3; attempt++) { if (result.Status == TextOperationStatusCodes.Failed || result.Status == TextOperationStatusCodes.Succeeded) { break; } Debug.WriteLine(string.Format("Server status: {0}, wait {1} seconds...", result.Status, TimeSpan.FromSeconds(3))); await Task.Delay(TimeSpan.FromSeconds(3)); Debug.WriteLine("Calling ComputerVisionClient.GetTextOperationResultAsync()..."); result = await client.GetTextOperationResultAsync(operationId); } } catch (Exception ex) { result = new TextOperationResult() { Status = TextOperationStatusCodes.Failed }; Debug.WriteLine(ex.Message); } return(result); } }
private void InitTextAnalyticsClient() { _credentials = new ApiKeyServiceClientCredentials(TextSubscriptionKey); _client = new TextAnalyticsClient(_credentials) { Endpoint = TextEndPoint }; }
public LuisNLP(IConfiguration config) { this.config = config; this.credentials = new ApiKeyServiceClientCredentials(config["Luis.AuthoringKey"]); this.luisClient = new LUISRuntimeClient(credentials); this.luisClient.Endpoint = config["Luis.Endpoint"]; this.prediction = new Prediction(luisClient); }
public MainCameraPageViewController(IntPtr handle) : base(handle) { httpClient = new HttpClient(); var credentials = new ApiKeyServiceClientCredentials(Help.PrivateKeys.CognitiveServicesKey); computerVisionClient = new ComputerVisionClient(credentials, httpClient, false); computerVisionClient.Endpoint = Help.PrivateKeys.CognitiveServicesEndpoint; }
public async Task <LuisResult> ExtractEntitiesFromLUIS(string textToAnalyze) { var method = "ExtractEntitiesFromLUIS"; try { _logger.LogInformation(string.Format("{0} - {1}", method, "IN")); _logger.LogInformation(string.Format("{0} - {1}", method, "Getting credentials.")); var subscriptionKey = Environment.GetEnvironmentVariable("LUISAPISubscriptionKey"); if (subscriptionKey == null) { throw new System.ArgumentNullException("subscriptionKey"); } var credentials = new ApiKeyServiceClientCredentials(Environment.GetEnvironmentVariable("LUISAPISubscriptionKey")); _logger.LogInformation(string.Format("{0} - {1}", method, "Creating client.")); var client = new LUISRuntimeClient(credentials); _logger.LogInformation(string.Format("{0} - {1}", method, "Setting Endpoint")); client.Endpoint = "https://westeurope.api.cognitive.microsoft.com/"; _logger.LogInformation(string.Format("{0} - {1}", method, "Getting app ID.")); var appID = Environment.GetEnvironmentVariable("LUISAPPID"); if (appID == null) { throw new System.ArgumentNullException("appID"); } _logger.LogInformation(string.Format("{0} - {1}", method, "Getting Bing Subscription Key.")); var bingSubcriptionKey = Environment.GetEnvironmentVariable("BingAPISubscriptionKey"); if (bingSubcriptionKey == null) { throw new System.ArgumentNullException("bingSubcriptionKey"); } _logger.LogInformation(string.Format("{0} - {1}", method, "Predicting.")); return(await _predictionHelperService.ResolveAsync(client.Prediction, appID, textToAnalyze, null, null, false, true, bingSubcriptionKey)); } catch (ArgumentNullException arg) { _logger.LogError(string.Format("{0} - {1}", method, "Received a null argument.")); _logger.LogError(string.Format("{0} - {1}", method, "Argument:")); _logger.LogError(string.Format("{0} - {1}", method, arg.ParamName)); return(null); } catch (Exception ex) { _logger.LogError(string.Format("{0} - {1}", method, "Generic Exception.")); _logger.LogError(string.Format("{0} - {1}", method, "Message:")); _logger.LogError(string.Format("{0} - {1}", method, ex.Message)); return(null); } }
private static void InitComputer() { var credenciales = new ApiKeyServiceClientCredentials(APIKEY); Cliente = new ComputerVisionClient(credenciales) { Endpoint = ENDPOINT }; }