public Task <ServiceResponse <AnalyzeResponse> > SendAnalysisAsync(AnalyzeRequest a) { var response = _requestAnalyzer.AnalyzeRequest(a, Guid.NewGuid().ToString()); var serviceResponse = new ServiceResponse <AnalyzeResponse>(response); return(Task.FromResult(serviceResponse)); }
public Task <ServiceResponse <byte[]> > SendAnalysisAsync(AnalyzeRequest a, string format) { var sortedAnalyzeRequest = new AnalyzeRequest { RequestFlags = a.RequestFlags, Dependencies = a.Dependencies .OrderBy(t => t.Key.MemberDocId) .ThenBy(t => t.Key.TypeDocId) .ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>), UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal), UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary .OrderBy(t => t.Key) .ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>), UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies), AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal), Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal), ApplicationName = a.ApplicationName, Version = a.Version, BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress ?? Enumerable.Empty <string>(), StringComparer.Ordinal), AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity) }; var result = sortedAnalyzeRequest.Serialize(); return(Task.FromResult(ServiceResponse.Create(result))); }
public async Task <PerspectiveAnalysisResponse> Analyze(PerspectiveAnalysisRequest request) { var url = $"https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze?key={_perspectiveApiOptions.ApiKey}"; var analyzeRequest = new AnalyzeRequest { Comment = new AnalyzeComment { Text = request.Text }, RequestedAttributes = new Dictionary <string, object> { { KnownPerspectiveAnalysisAttributes.Toxicity, new object() }, { KnownPerspectiveAnalysisAttributes.IdentityAttack, new object() }, { KnownPerspectiveAnalysisAttributes.SexuallyExplicit, new object() }, }, Languages = new [] { "en" } }; var analyzeResponse = await _httpClient.Post <AnalyzeResponse>(url, analyzeRequest); var response = new PerspectiveAnalysisResponse { Text = request.Text, AttributeScores = analyzeResponse.AttributeScores.ToDictionary( x => x.Key, x => x.Value.SummaryScore.Value) }; return(response); }
private byte[] SerializeRequest(AnalyzeRequest a) { var sortedAnalyzeRequest = new AnalyzeRequest { RequestFlags = a.RequestFlags, Dependencies = a.Dependencies .OrderBy(t => t.Key.MemberDocId) .ThenBy(t => t.Key.TypeDocId) .ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>), UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal), UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary .OrderBy(t => t.Key) .ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>), NonUserAssemblies = new SortedSet <AssemblyInfo>(a.NonUserAssemblies), UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies), AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal), Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal), ApplicationName = a.ApplicationName, Version = a.Version, BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress ?? Enumerable.Empty <string>(), StringComparer.Ordinal), AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity) }; return(sortedAnalyzeRequest.Serialize()); }
public void AnalyzeTest() { var request = new AnalyzeRequest("text to analyze"); var result = this.Client.Analyze(request); result.IsValid.Should().BeTrue(); }
private void WriteOutput(AnalyzeRequest a) { var sortedAnalyzeRequest = new AnalyzeRequest { RequestFlags = a.RequestFlags, Dependencies = a.Dependencies .OrderBy(t => t.Key.MemberDocId) .ThenBy(t => t.Key.TypeDocId) .ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>), UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal), UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary .OrderBy(t => t.Key) .ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>), UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies), AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal), Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal), ApplicationName = a.ApplicationName, Version = a.Version, BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress, StringComparer.Ordinal), AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity) }; var tmp = $"{Path.GetTempFileName()}.json"; using (var ms = new MemoryStream(sortedAnalyzeRequest.Serialize())) using (var fs = File.OpenWrite(tmp)) { ms.CopyTo(fs); } Process.Start(tmp); }
public List <RecognizerResult> Analyze(string text) { var analyzerRequest = new AnalyzeRequest(text, analyzerLanguage); var result = analyzer.AnalyzePost(analyzerRequest); return(result.Select(r => new RecognizerResult(r.Start, r.End, r.Score, r.EntityType)).ToList()); }
public void SerializeAnalyzeRequest() { var request = new AnalyzeRequest { ApplicationName = "name", Dependencies = GetDependencies(), Targets = new List <string> { "target1", "target2" }, UnresolvedAssemblies = new List <string> { "assembly1", "assembly2" }, UserAssemblies = new List <AssemblyInfo> { new AssemblyInfo { AssemblyIdentity = "name1" }, new AssemblyInfo { AssemblyIdentity = "name2" } }, Version = AnalyzeRequest.CurrentVersion }; var newtonsoft = request.Serialize().Deserialize <AnalyzeRequest>(); var dcjs = DeserializeObjectDcjs <AnalyzeRequest>(SerializeDcjs(request)); CompareAnalyzeRequest(request, newtonsoft); CompareAnalyzeRequest(request, dcjs); }
/// <summary> /// Creates a new environment. You can only create one environment per service instance.An attempt to create another environment /// will result in an error. The size of the new environment can be controlled by specifying the size parameter. /// </summary> /// <param name="callback">The OnAnalyze callback.</param> /// <param name="parameters">The analyze parameters.</param> /// <param name="customData">Optional custom data.</param> /// <returns>True if the call succeeds, false if the call is unsuccessful.</returns> public bool Analyze(OnAnalyze callback, Parameters parameters, string customData = default(string)) { if (callback == null) { throw new ArgumentNullException("callback"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } AnalyzeRequest req = new AnalyzeRequest(); req.Callback = callback; req._Parameters = parameters; req.Data = customData; req.OnResponse = OnAnalyzeResponse; req.Headers["Content-Type"] = "application/json"; req.Headers["Accept"] = "application/json"; req.Parameters["version"] = NaturalLanguageUnderstandingVersion.Version; fsData data = null; fsResult r = sm_Serializer.TrySerialize(parameters, out data); string sendjson = data.ToString(); req.Send = Encoding.UTF8.GetBytes(sendjson); RESTConnector connector = RESTConnector.GetConnector(SERVICE_ID, SERVICE_ANALYZE); if (connector == null) { return(false); } return(connector.Send(req)); }
private ReportingResult GetReportingResult(AnalyzeRequest request, AnalyzeResponse response, IDependencyInfo dependencyInfo) { if (response == null) { return(null); } using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport)) { try { return(_reportGenerator.ComputeReport( response.Targets, response.SubmissionId, request.RequestFlags, dependencyInfo?.Dependencies, response.MissingDependencies, dependencyInfo?.UnresolvedAssemblies, response.UnresolvedUserAssemblies, dependencyInfo?.AssembliesWithErrors, response.NuGetPackages )); } catch (Exception) { progressTask.Abort(); throw; } } }
public List <RecognizerResultWithAnalysis> AnalyzePost(AnalyzeRequest analyzeRequest) { return(new List <RecognizerResultWithAnalysis> { new RecognizerResultWithAnalysis(start: DefaultStart, end: DefaultEnd, score: DefaultScore, entityType: EntityType) }); }
/// <summary> /// Gets the Portability of an application as a ReportingResult. /// </summary> /// <returns>Set of APIs/assemblies that are not portable/missing.</returns> private async Task <ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo) { var fullResponse = await RetrieveResultAsync(request); CheckEndpointStatus(fullResponse.Headers.Status); using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport)) { try { var response = fullResponse.Response; return(_reportGenerator.ComputeReport( response.Targets, response.SubmissionId, request.RequestFlags, dependencyInfo?.Dependencies, response.MissingDependencies, dependencyInfo?.UnresolvedAssemblies, response.UnresolvedUserAssemblies, dependencyInfo?.AssembliesWithErrors )); } catch (Exception) { progressTask.Abort(); throw; } } }
/// <summary> /// Gets an analysis report based on the options supplied /// </summary> /// <param name="options">Options to generate report</param> /// <returns>A collection of reports</returns> private async Task <IEnumerable <byte[]> > GetAnalysisResultAsync(IApiPortOptions options) { var dependencyInfo = _dependencyFinder.FindDependencies(options.InputAssemblies, _progressReport); if (dependencyInfo.UserAssemblies.Any()) { AnalyzeRequest request = GenerateRequest(options, dependencyInfo); // Create the progress reporter here (instead of within GetResultFromServiceAsync) since the reporter does not work well when run in parallel using (var progressTask = _progressReport.StartTask(LocalizedStrings.SendingDataToService)) { try { var tasks = options.OutputFormats .Select(f => GetResultFromServiceAsync(request, f)) .ToList(); await Task.WhenAll(tasks); return(tasks.Select(t => t.Result).ToList()); } catch (Exception) { progressTask.Abort(); throw; } } } else { _progressReport.ReportIssue(LocalizedStrings.NoFilesAvailableToUpload); return(Enumerable.Empty <byte[]>()); } }
public void AnalyzeEmptyStringDoesNotThrow() { var request = new AnalyzeRequest(string.Empty); var result = this.Client.Analyze(request); result.IsValid.Should().BeFalse(); }
/// <summary> /// Gets the Portability of an application as a ReportingResult. /// </summary> /// <returns>Set of APIs/assemblies that are not portable/missing.</returns> private async Task <ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo) { var fullResponse = await RetrieveResultAsync(request); CheckEndpointStatus(fullResponse.Headers.Status); return(GetReportingResult(request, fullResponse.Response, dependencyInfo)); }
public void UrlSetterNoTrimTest() { var body = new AnalyzeRequest { Url = "https://www.google.com" }; Assert.AreEqual("https://www.google.com", body.Url); }
public async Task <ServiceResponse <byte[]> > SendAnalysisAsync(AnalyzeRequest a, string format) { var formatInformation = await GetResultFormat(format); var sendAnalysis = _endpoint + Endpoints.Analyze; return(await _client.CallAsync(HttpMethod.Post, sendAnalysis, a, formatInformation)); }
public Task AddAsync(AnalyzeRequest request) { var bytes = _serializer.Serialize(request); _model.BasicPublish(Constants.Exchange, Constants.Routing, null, bytes); return(Task.CompletedTask); }
/// <summary> /// Gets the Portability report for the request. /// </summary> /// <returns>An array of bytes corresponding to the report.</returns> private async Task <byte[]> GetResultFromServiceAsync(AnalyzeRequest request, string format) { var response = await _apiPortService.SendAnalysisAsync(request, format); CheckEndpointStatus(response.Headers.Status); return(response.Response); }
public AnalyzeResponse AnalyzeRequest(AnalyzeRequest request, string submissionId) { // Get the list of targets we should consider in the analysis var targets = _targetNameParser .MapTargetsToExplicitVersions(request.Targets.SelectMany(_targetMapper.GetNames)) .OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase) .ToList(); // TODO: It's possible that an AssemblyInfo in UserAssemblies is null. // This appears to be coming from analysis in the VSIX, possibly // from CCI. Figure out where this is coming from. var assemblyIdentities = request?.UserAssemblies.Where(x => x != null && x.AssemblyIdentity != null).Select(a => a.AssemblyIdentity) ?? Enumerable.Empty <string>(); var userAssemblies = new HashSet <string>(assemblyIdentities, StringComparer.OrdinalIgnoreCase); var notInAnyTarget = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowNonPortableApis) ? _analysisEngine.FindMembersNotInTargets(targets, userAssemblies, request.Dependencies) : new List <MemberInfo>(); var unresolvedAssemblies = request.UnresolvedAssembliesDictionary != null ? request.UnresolvedAssembliesDictionary.Keys : request.UnresolvedAssemblies; var missingUserAssemblies = _analysisEngine.FindUnreferencedAssemblies(unresolvedAssemblies, request.UserAssemblies).ToList(); var breakingChangeSkippedAssemblies = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges) ? _analysisEngine.FindBreakingChangeSkippedAssemblies(targets, request.UserAssemblies, request.AssembliesToIgnore).ToList() : new List <AssemblyInfo>(); var breakingChanges = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges) ? _analysisEngine.FindBreakingChanges(targets, request.Dependencies, breakingChangeSkippedAssemblies, request.BreakingChangesToSuppress, userAssemblies, request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowRetargettingIssues)).ToList() : new List <BreakingChangeDependency>(); var reportingResult = _reportGenerator.ComputeReport( targets, submissionId, request.RequestFlags, request.Dependencies, notInAnyTarget, request.UnresolvedAssembliesDictionary, missingUserAssemblies, request.AssembliesWithErrors); return(new AnalyzeResponse { CatalogLastUpdated = _analysisEngine.CatalogLastUpdated, ApplicationName = request.ApplicationName, MissingDependencies = notInAnyTarget, UnresolvedUserAssemblies = missingUserAssemblies, Targets = targets, ReportingResult = reportingResult, SubmissionId = submissionId, BreakingChanges = breakingChanges, BreakingChangeSkippedAssemblies = breakingChangeSkippedAssemblies }); }
public AnalyzeRequestTests() { var request = new AnalyzeRequest("analyze this text") { Indices = new IndexNameMarker[] { typeof(ElasticsearchProject)}, Field = Property.Path<ElasticsearchProject>(p=>p.Name) }; var response = this._client.Analyze(request); this._status = response.ConnectionStatus; }
public AnalyzeRequestTests() { var request = new AnalyzeRequest("analyze this text") { Indices = new IndexNameMarker[] { typeof(ElasticsearchProject) }, Field = Property.Path <ElasticsearchProject>(p => p.Name) }; var response = this._client.Analyze(request); this._status = response.ConnectionStatus; }
/// <summary> /// Creates a new environment. You can only create one environment per service instance.An attempt to create another environment /// will result in an error. The size of the new environment can be controlled by specifying the size parameter. /// </summary> /// <param name="successCallback">The success callback.</param> /// <param name="failCallback">The fail callback.</param> /// <param name="parameters">The analyze parameters.</param> /// <param name="customData">Optional custom data.</param> /// <returns>True if the call succeeds, false if the call is unsuccessful.</returns> public bool Analyze(SuccessCallback <AnalysisResults> successCallback, FailCallback failCallback, Parameters parameters, Dictionary <string, object> customData = null) { if (successCallback == null) { throw new ArgumentNullException("successCallback"); } if (failCallback == null) { throw new ArgumentNullException("failCallback"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } AnalyzeRequest req = new AnalyzeRequest(); req.SuccessCallback = successCallback; req.FailCallback = failCallback; req.HttpMethod = UnityWebRequest.kHttpVerbPOST; req.DisableSslVerification = DisableSslVerification; req.CustomData = customData == null ? new Dictionary <string, object>() : customData; if (req.CustomData.ContainsKey(Constants.String.CUSTOM_REQUEST_HEADERS)) { foreach (KeyValuePair <string, string> kvp in req.CustomData[Constants.String.CUSTOM_REQUEST_HEADERS] as Dictionary <string, string> ) { req.Headers.Add(kvp.Key, kvp.Value); } } req.OnResponse = OnAnalyzeResponse; req.Headers["X-IBMCloud-SDK-Analytics"] = "service_name=natural_language_understanding;service_version=v1;operation_id=Analyze"; req.Headers["Content-Type"] = "application/json"; req.Headers["Accept"] = "application/json"; req.Parameters["version"] = NaturalLanguageUnderstandingVersion.Version; fsData data = null; _serializer.TrySerialize(parameters, out data); string sendjson = data.ToString(); req.Send = Encoding.UTF8.GetBytes(sendjson); RESTConnector connector = RESTConnector.GetConnector(Credentials, AnalyzeEndpoint); if (connector == null) { return(false); } return(connector.Send(req)); }
public virtual Response <AnalyzeResult> Analyze(string indexName, AnalyzeRequest request, RequestOptions requestOptions = null, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("IndexesClient.Analyze"); scope.Start(); try { return(RestClient.Analyze(indexName, request, requestOptions, cancellationToken)); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// 分词 /// </summary> /// <param name="strSentence"></param> /// <returns></returns> public static List <string> GetTokenList(string strSentence) { AnalyzeRequest a = new AnalyzeRequest(); a.Text = new string[] { strSentence }; a.Tokenizer = TokenizerName; var result = client.Analyze(a); if (result.Tokens == null) { return(null); } return(result.Tokens.Select(x => x.Token).ToList <string>()); }
/// <summary> /// Gets an analysis report based on the options supplied /// </summary> /// <param name="options">Options to generate report</param> /// <returns>A collection of reports</returns> private async Task <MultipleFormatAnalysis> GetAnalysisResultAsync(IApiPortOptions options) { var dependencyInfo = _dependencyFinder.FindDependencies(options.InputAssemblies, _progressReport); if (dependencyInfo.UserAssemblies.Any()) { AnalyzeRequest request = GenerateRequest(options, dependencyInfo); // Create the progress reporter here (instead of within GetResultFromServiceAsync) since the reporter does not work well when run in parallel using (var progressTask = _progressReport.StartTask(LocalizedStrings.AnalyzingCompatibility)) { try { var tasks = options.OutputFormats .Select(f => new { Format = f, Task = GetResultFromServiceAsync(request, f) }) .ToList(); await Task.WhenAll(tasks.Select(t => t.Task)); var results = tasks.Select(t => new ReportingResultWithFormat { Data = t.Task.Result, Format = t.Format, }).ToList(); return(new MultipleFormatAnalysis { Info = dependencyInfo, Request = request, Results = results }); } catch (Exception) { progressTask.Abort(); throw; } } } else { _progressReport.ReportIssue(LocalizedStrings.NoFilesAvailableToUpload); return(new MultipleFormatAnalysis { Results = Enumerable.Empty <ReportingResultWithFormat>() }); } }
public AnalyzeResponse AnalyzeRequest(AnalyzeRequest request, string submissionId) { // Get the list of targets we should consider in the analysis var targets = _targetNameParser .MapTargetsToExplicitVersions(request.Targets.SelectMany(_targetMapper.GetNames)) .OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase) .ToList(); var notInAnyTarget = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowNonPortableApis) ? _analysisEngine.FindMembersNotInTargets(targets, request.Dependencies) : new List <MemberInfo>(); var unresolvedAssemblies = request.UnresolvedAssembliesDictionary != null ? request.UnresolvedAssembliesDictionary.Keys : request.UnresolvedAssemblies; var missingUserAssemblies = _analysisEngine.FindUnreferencedAssemblies(unresolvedAssemblies, request.UserAssemblies).ToList(); var breakingChangeSkippedAssemblies = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges) ? _analysisEngine.FindBreakingChangeSkippedAssemblies(targets, request.UserAssemblies, request.AssembliesToIgnore).ToList() : new List <AssemblyInfo>(); var breakingChanges = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges) ? _analysisEngine.FindBreakingChanges(targets, request.Dependencies, breakingChangeSkippedAssemblies, request.BreakingChangesToSuppress, request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowRetargettingIssues)).ToList() : new List <BreakingChangeDependency>(); var reportingResult = _reportGenerator.ComputeReport( targets, submissionId, request.RequestFlags, request.Dependencies, notInAnyTarget, request.UnresolvedAssembliesDictionary, missingUserAssemblies, request.AssembliesWithErrors); return(new AnalyzeResponse { CatalogLastUpdated = _analysisEngine.CatalogLastUpdated, ApplicationName = request.ApplicationName, MissingDependencies = notInAnyTarget, UnresolvedUserAssemblies = missingUserAssemblies, Targets = targets, ReportingResult = reportingResult, SubmissionId = submissionId, BreakingChanges = breakingChanges, BreakingChangeSkippedAssemblies = breakingChangeSkippedAssemblies }); }
public IEnumerable <string> Analyze(string text, int nGramCount) { if (string.IsNullOrEmpty(text)) { return(new List <string>()); } var request = new AnalyzeRequest(IndexName, text) { Analyzer = $"{_analyzerPrefix}{nGramCount}" }; var result = Client.Analyze(request); ResponseValidator(result); return(result.Tokens.Select(t => t.Token)); }
private async Task <ServiceResponse <AnalyzeResponse> > RetrieveResultAsync(AnalyzeRequest request) { using (var progressTask = _progressReport.StartTask(LocalizedStrings.AnalyzingCompatibility)) { try { return(await _apiPortService.SendAnalysisAsync(request)); } catch (Exception) { progressTask.Abort(); throw; } } }
public async Task <IssueResults> Nuget([FromBody] NuGetRequest nuGetRequest) { var results = await _storage.CreateAsync(CancellationToken.None); var request = new AnalyzeRequest { Id = results.Id, Original = nuGetRequest.Original, Updated = nuGetRequest.Updated }; await _queue.AddAsync(request); return(results); }
public async Task <IActionResult> PostBookmark([Required][FromBody] AnalyzeRequest request) { var bookmark = await _dbContext.GetBookmarkFromUrlAsync(request.Url); if (bookmark != null) { throw new NoBookmarkExitsException("Bookmark already exists", request.Url); } var results = _naturalLanguageService.Analyze(request.Url); bookmark = new Bookmark(results, request.Tags); bookmark = await _dbContext.AddBookmarkAsync(bookmark); return(Created(bookmark.Path, bookmark)); }