private static void RunAnalysis(AnalysisOptions opts)
{
Console.WriteLine(
ConsoleOutput.PrintAnalysisResult(
// FIXME distinguish between string and string[] here. Maybe with a simple mapping of prog names to output type
Analyze <string>(opts.ProgramName, Config.SAMPLE_DIRECTORY + opts.Path, opts.Verbose, true), 0, opts.Verbose));
}
public async Task LinterOnOff() {
const string code = @"a = x";
var analysis = await GetAnalysisAsync(code);
var a = Services.GetService<IPythonAnalyzer>();
var d = a.LintModule(analysis.Document);
d.Should().HaveCount(1);
var provider = Substitute.For<IAnalysisOptionsProvider>();
Services.AddService(provider);
var ds = Services.GetService<IDiagnosticsService>();
var options = new AnalysisOptions();
provider.Options.Returns(_ => options);
options.LintingEnabled = true;
PublishDiagnostics();
ds.Diagnostics[analysis.Document.Uri].Should().HaveCount(1);
LanguageServer.HandleLintingOnOff(Services, false);
options.LintingEnabled.Should().BeFalse();
PublishDiagnostics();
ds.Diagnostics[analysis.Document.Uri].Should().BeEmpty();
LanguageServer.HandleLintingOnOff(Services, true);
options.LintingEnabled.Should().BeTrue();
PublishDiagnostics();
ds.Diagnostics[analysis.Document.Uri].Should().HaveCount(1);
}
public static ParametersPack Create(
AnalysisOptions analysisOptions,
AlgorithmType algorithmType,
int startValue,
int endValue,
int extrapolationSegmentValue,
int launchesNumber,
int step)
{
analysisOptions.ThrowIfNull(nameof(analysisOptions));
algorithmType.ThrowIfNull(nameof(algorithmType));
return(new ParametersPack(
analysisProgramName: new FileInfo(algorithmType.AnalysisProgramName),
algorithmType: algorithmType,
startValue: startValue,
endValue: endValue,
extrapolationSegmentValue: extrapolationSegmentValue,
launchesNumber: launchesNumber,
step: step,
outputFilenamePattern: PathHelper.ResolveFullPath(algorithmType.OutputFilenamePattern),
commonAnalysisFilenameSuffix: analysisOptions.CommonAnalysisFilenameSuffix,
outputFileExtension: analysisOptions.OutputFileExtension
));
}
internal void LinkAsts(AnalysisOptions options)
{
if (this.astLinkWorker.IsBusy)
{
return;
}
this.astLinkWorker.RunWorkerAsync(options);
}
internal void ParseAst(AnalysisOptions options)
{
if (this.astWorker.IsBusy)
{
return;
}
this.astWorker.RunWorkerAsync(options);
}
internal void CommitsToDb(AnalysisOptions options)
{
if (this.commitWorker.IsBusy)
{
return;
}
this.commitWorker.RunWorkerAsync(options);
}
public IRequest Marshall(DefineAnalysisSchemeRequest defineAnalysisSchemeRequest)
{
IRequest request = new DefaultRequest(defineAnalysisSchemeRequest, "AmazonCloudSearch");
request.Parameters.Add("Action", "DefineAnalysisScheme");
request.Parameters.Add("Version", "2013-01-01");
if (defineAnalysisSchemeRequest != null && defineAnalysisSchemeRequest.IsSetDomainName())
{
request.Parameters.Add("DomainName", StringUtils.FromString(defineAnalysisSchemeRequest.DomainName));
}
if (defineAnalysisSchemeRequest != null)
{
AnalysisScheme analysisScheme = defineAnalysisSchemeRequest.AnalysisScheme;
if (analysisScheme != null && analysisScheme.IsSetAnalysisSchemeName())
{
request.Parameters.Add("AnalysisScheme.AnalysisSchemeName", StringUtils.FromString(analysisScheme.AnalysisSchemeName));
}
if (analysisScheme != null && analysisScheme.IsSetAnalysisSchemeLanguage())
{
request.Parameters.Add("AnalysisScheme.AnalysisSchemeLanguage", StringUtils.FromString(analysisScheme.AnalysisSchemeLanguage));
}
if (analysisScheme != null)
{
AnalysisOptions analysisOptions = analysisScheme.AnalysisOptions;
if (analysisOptions != null && analysisOptions.IsSetSynonyms())
{
request.Parameters.Add("AnalysisScheme.AnalysisOptions.Synonyms", StringUtils.FromString(analysisOptions.Synonyms));
}
if (analysisOptions != null && analysisOptions.IsSetStopwords())
{
request.Parameters.Add("AnalysisScheme.AnalysisOptions.Stopwords", StringUtils.FromString(analysisOptions.Stopwords));
}
if (analysisOptions != null && analysisOptions.IsSetStemmingDictionary())
{
request.Parameters.Add("AnalysisScheme.AnalysisOptions.StemmingDictionary", StringUtils.FromString(analysisOptions.StemmingDictionary));
}
if (analysisOptions != null && analysisOptions.IsSetAlgorithmicStemming())
{
request.Parameters.Add("AnalysisScheme.AnalysisOptions.AlgorithmicStemming", StringUtils.FromString(analysisOptions.AlgorithmicStemming));
}
}
}
return(request);
}
private void ResetAlgorithmSettingsSafe()
{
_logger.Info("Resetting algorithm settings to default values (as in config file).");
try
{
AnalysisOptions analysisOptions = ConfigOptions.Analysis;
Settings.Analysis.ResetAlgorithmSettings(analysisOptions);
}
catch (Exception ex)
{
string message = $"Failed to reset algorithm settings: {ex.Message}";
_logger.Error(ex, message);
MessageBoxProvider.ShowError(message);
}
}
static void TestAnalysis()
{
string key = "宝马x1";
var query = new SolrSelectRequest();
var handler = SolrServerInstance.NewsServer.GetHandler <SolrAnalysisHandler>();
handler.Collection = "web";
var analysisOpt = new AnalysisOptions();
analysisOpt._ = DateTime.Now.ToLongTimeString();
analysisOpt.fieldtype = "text_complex";
analysisOpt.query = key;
analysisOpt.showmatch = "true";
analysisOpt.verbose_output = 0;
query.ExtraOptions.Add(analysisOpt);
var response = handler.Request(query);
response.Wait();
var analysis = response.Result.GetData <List <AnalysisField> >("analysis.field_types.text_complex.query[-1:]");
Assert.IsTrue(analysis.Count >= 0);
}
public void Run(AnalysisOptions options)
{
Options.replicateType = options.replicateType;
Options.C = options.C;
Options.tauS = options.tauS;
Options.tauW = options.tauW;
Options.gamma = options.gamma;
Options.alpha = options.alpha;
Options.multipleIntersections = options.multipleIntersections;
Data <Peak, Metadata> .cachedChiSqrd = new List <double>();
for (int i = 1; i <= Data <Peak, Metadata> .sampleKeys.Count; i++)
{
Data <Peak, Metadata> .cachedChiSqrd.Add(Math.Round(ChiSquaredCache.ChiSqrdINVRTP(Options.gamma, (byte)(i * 2)), 3));
}
Data <Peak, Metadata> .BuildSharedItems();
processor = new Processor <Peak, Metadata>();
#region .::. Status .::.
int totalSteps = Data <Peak, Metadata> .sampleKeys.Count + 3;
int stepCounter = 0;
#endregion
Console.WriteLine("");
foreach (var sampleKey in Data <Peak, Metadata> .sampleKeys)
{
var sample = Samples <Peak, Metadata> .Data[sampleKey.Key];
#region .::. Status .::.
if (sampleKey.Value.Length > 36)
{
Console.Write("\r[" + (++stepCounter).ToString() + "\\" + totalSteps + "] processing sample: ..." + sampleKey.Value.Substring(sampleKey.Value.Length - 35, 35));
}
else
{
Console.Write("\r[" + (++stepCounter).ToString() + "\\" + totalSteps + "] processing sample: " + sampleKey.Value);
}
Console.WriteLine("");
#endregion
foreach (var chr in sample.intervals)
{
foreach (var strand in chr.Value)
{
int currentLineCursor = Console.CursorTop;
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write(new string(' ', Console.WindowWidth));
Console.SetCursorPosition(0, currentLineCursor);
Console.Write("\r .::. Processing {0}", chr.Key);
processor.Run(sampleKey.Key, chr.Key, strand.Key);
}
}
}
#region .::. Status .::.
Console.Write("\r[" + (++stepCounter).ToString() + "\\" + totalSteps + "] Purifying intermediate sets.");
#endregion
processor.IntermediateSetsPurification();
#region .::. Status .::.
Console.WriteLine("[" + (++stepCounter).ToString() + "\\" + totalSteps + "] Creating output set.");
#endregion
processor.CreateOuputSet();
#region .::. Status .::.
Console.WriteLine("[" + stepCounter + "\\" + totalSteps + "] Performing Multiple testing correction.");
#endregion
processor.EstimateFalseDiscoveryRate();
}
public void Update(AnalysisOptions option)
{
this.wrapper = new AnalysisBase(option.LocalPath, option.AnalysisPath);
this.wrapper.ProgressChanged += (per) => this.FireProgressUpdate(per);
this.wrapper.StatusChanged += (stat) => this.FireStatusUpdate(stat);
}
