public static TOutput RunCheckpoint <TConvention, TInput, TOutput>(this ICheckpointRunner runner, IMoveableResultCheckpoint <TConvention, TInput, TOutput> wrapper, TInput input, TConvention convention) { return(runner.RunCheckpoint(wrapper, input, wrapper.GetNamingConvention(convention))); }
public IParsingResult <IModeLauncher> Parse( MainParser main, ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner, IWorkDoer workDoer, string[] args, TextWriter standardWriter, TextWriter errorWriter) { var results = main.GetParseResults(args); var parsingResult = checkpointRunner.RunCheckpoint("Validate input", () => { if (!results.Validate(out IParsingResult <IModeLauncher> failedResult)) { return(ParsingResult <T> .FailedResult(failedResult.ErrorMessage)); } var successfulResults = new SuccessfulResultCollection(results); var commonOptions = successfulResults.Get(MainParser.CommonOptionsParser); return(GetSerializedResult(successfulResults, commonOptions)); }); if (!parsingResult.Success) { ShowError(main, logger.Error, parsingResult.ErrorMessage); return(ParsingResult <IModeLauncher> .FailedResult(parsingResult)); } var runner = GetRunner(parsingResult.Result); return(ParsingResult <IModeLauncher> .SuccessfulResult(new ModeLauncher(logger, settings, checkpointRunner, workDoer, runner, args, main.GetVersion(), Name))); }
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, IAbstractCheckpoint <TInput, TOutput> wrapper, TInput input, INamingConvention <TOutput> namingConvention) { return(runner.RunCheckpointAsync(wrapper.GetStepName(), wrapper, input, namingConvention)); }
public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner, IAbstractCheckpoint <TInput, TOutput> wrapper, TInput input, ILoadingConvention <TInput, TOutput> loadingConvention) { return(runner.RunCheckpoint(wrapper.GetStepName(), wrapper.Run, input, loadingConvention)); }
public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner, IAbstractCheckpoint <TInput, TOutput> wrapper, TInput input, INamingConvention <TOutput> namingConvention) { return(runner.RunCheckpoint(wrapper.GetStepName(), dir => wrapper.Run(input, dir), namingConvention)); }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams); var callset = GetCallset(); logger.Info($"Normal Vcf path: {callset.NormalVcfPath}"); runner.CallSample(callset); }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, true, CanvasCoverageMode.GCContentWeighted, 100, CommonOptions.CustomParams); var callset = GetCallset(); runner.CallSample(callset); }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams); var callset = GetCallset(); var spwWorkflow = new SmallPedigreeWorkflow(runner); spwWorkflow.CallPedigree(callset); }
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner runner, string name, Func <IDirectoryLocation, TResult> run, INamingConvention <TResult> namingConvention) { return(runner.RunCheckpoint(name, (dir, mover) => { var result = run(dir); return namingConvention.Move(result, mover.Move); })); }
private IParsingResult <IModeLauncher> Parse( ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner, IWorkDoer workDoer, string[] args, TextWriter standardWriter, TextWriter errorWriter) { var mode = _modeParsers[args[0]]; return(mode.Parse(this, logger, settings, checkpointRunner, workDoer, args, standardWriter, errorWriter)); }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams); var callset = GetCallset(); logger.Info($"Normal Vcf path: {callset.SingleSampleCallset.NormalVcfPath}"); runner.CallSample(callset); }
public static TResult RunCheckpoint <TInput, TResult>(this ICheckpointRunner runner, string name, Func <TInput, IDirectoryLocation, TResult> run, TInput input, ILoadingConvention <TInput, TResult> loadingConvention) { return(runner.RunCheckpoint(name, (dir, mover) => { var result = run(input, dir); loadingConvention.Move(result, mover.Move); return loadingConvention.Load(input); }, () => loadingConvention.Load(input))); }
public CanvasRunnerFactory(ILogger logger, ICheckpointRunner checkpointRunner, IWorkDoer workDoer, IFileLocation runtimeExecutable, Func <string, ICommandFactory> runtimeCommandPrefix) { _logger = logger; _checkpointRunner = checkpointRunner; _workDoer = workDoer; _runtimeExecutable = runtimeExecutable; _runtimeCommandPrefix = runtimeCommandPrefix; }
public static Task <TOutput> RunCheckpointAsync <TOutput>(this ICheckpointRunner runner, string key, Func <IDirectoryLocation, TOutput> run, INamingConvention <TOutput> namingConvention) { var asyncNamingConvention = new NamingConventionAsync <TOutput>(namingConvention); return(runner.RunCheckpoint(key, dir => Task.Run(() => run(dir)), asyncNamingConvention)); }
public CanvasRunner(ILogger logger, IWorkManager workManager, ICheckpointRunner checkpointRunner, bool isSomatic, CanvasCoverageMode coverageMode, int countsPerBin, Dictionary<string, string> customParameters = null) { _logger = logger; _workManager = workManager; _checkpointRunner = checkpointRunner; _isSomatic = isSomatic; _canvasFolder = Path.Combine(Utilities.GetAssemblyFolder(typeof(CanvasRunner))); _coverageMode = coverageMode; _countsPerBin = countsPerBin; if (customParameters != null) { _customParameters = customParameters; } }
public ModeLauncher( ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner, IWorkDoer workDoer, IModeRunner modeRunner, IEnumerable <string> args, string version, string mode) { _logger = logger; _settings = settings; _checkpointRunner = checkpointRunner; _workDoer = workDoer; _modeRunner = modeRunner; _args = args; _version = version; _mode = mode; }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, true, CanvasCoverageMode.TruncatedDynamicRange, 300, CommonOptions.CustomParams); var callset = GetCallset(logger); runner.CallSample(callset); }
public Task <SampleSet <TCanvasOutput> > RunAsync(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner) { return(Task.FromResult(inputs.SelectData(input => default(TCanvasOutput)))); }
public Task <SampleSet <TCanvasOutput> > RunAsync(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner) { return(checkpointRunner.RunCheckpointAsync(_canvasCheckpoint, inputs, sampleStubNamingConvention)); }
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, string key, ISandboxedCheckpoint <TInput, TOutput> wrapper, TInput input, INamingConvention <TOutput> namingConvention) { return(runner.RunCheckpointAsync(key, dir => wrapper.Run(input, dir), namingConvention)); }
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <TResult> function) { return(checkpointRunner.RunCheckpoint(checkpointName, () => Task.Run(function))); }
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager) { CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, true, CanvasCoverageMode.GCContentWeighted, 100, CommonOptions.CustomParams); var callset = GetCallset(); runner.CallSample(callset); }
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string key, Func <TResult> run, Func <TResult> load) { return(checkpointRunner.RunCheckpoint(key, () => Task.Run(run), () => Task.Run(load))); }
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <ICheckpointRunner, IDirectoryLocation, IFileMover, TResult> run) { return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => run(checkpointRunner, tempDir, fileMover))); }
public static Task <TOutput> RunCheckpointAsync <TConvention, TInput, TOutput>(this ICheckpointRunner runner, ILoadableResultCheckpoint <TConvention, TInput, TOutput> wrapper, TInput input, TConvention convention) { return(runner.RunCheckpointAsync(wrapper, input, wrapper.GetLoadingConvention(convention))); }
public SampleSet <TCanvasOutput> Run(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner) { return(inputs.SelectData(input => default(TCanvasOutput))); }
/// <summary> /// /// </summary> /// <param name="runner"></param> /// <param name="key"></param> /// <param name="wrapper"></param> /// <param name="input"></param> /// <param name="loadingConvention"></param> /// <typeparam name="TInput"></typeparam> /// <typeparam name="TOutput"></typeparam> /// <returns></returns> /// <exception cref="NotImplementedException"></exception> public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, string key, ISandboxedCheckpoint <TInput, TOutput> wrapper, TInput input, ILoadingConvention <TInput, TOutput> loadingConvention) { var asyncLoadingConvention = new LoadingConventionAsync <TInput, TOutput>(loadingConvention); return(runner.RunCheckpoint(key, (tempInput, dir) => Task.Run(() => wrapper.Run(tempInput, dir)), input, asyncLoadingConvention)); }
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <IDirectoryLocation, IFileMover, TResult> function, Func <TResult> load) { return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => Task.Run(() => function(tempDir, fileMover)), () => Task.Run(load))); }