public IActionResult DownloadToHtml(JupyterPreviewModel model)
{
var jupyterText = model.PreviewJson;
if (!string.IsNullOrEmpty(jupyterText))
{
//convert to document
var document = Jupyter.Parse(jupyterText);
//convert to html
string fileName = "jupyterDocument.html";
byte[] fileBytes = null;
using (var memoryStream = new MemoryStream())
{
using (var writer = new StreamWriter(memoryStream))
{
var htmlRenderer = new HtmlRenderer(writer)
{
RendererHeaderAndFooter = true
};
htmlRenderer.Render(document);
}
fileBytes = memoryStream.ToArray();
}
//diwnload
return(File(fileBytes, "application/force-download", fileName));
}
return(RedirectToAction("Index"));
}
public void TestReadingJpyterDocument1()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("Discover Sentiments in Tweets.ipynb");
var document = Jupyter.Parse(jupyterText);
Assert.IsTrue(document != null); //Phase success
}
public void TestReadingJpyterDocument2()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("01-Python Crash Course.ipynb");
var document = Jupyter.Parse(jupyterText);
Assert.IsTrue(document != null); //Phase success
}
public void TestCodeCellExecuteOutput()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""code"",
""execution_count"": 7,
""metadata"": {},
""outputs"": [
{
""data"": {
""text/plain"": ""Hello""
},
""execution_count"": 7,
""metadata"": {},
""output_type"": ""execute_result""
}
],
""source"": [
""1 * 3""
]
}]
}";
var document = Jupyter.Parse(jupyterText);
var codeCell = document.Cells.FirstOrDefault() as CodeCell;
var codeOutput = codeCell.Outputs.FirstOrDefault() as ExecuteResultOutput;
Assert.AreEqual(OutputType.ExecuteResult, codeOutput.OutputType); //Type
Assert.AreEqual(7, codeOutput.ExecutionCount); //ExecutionCount
Assert.AreEqual(null, codeOutput.MetaData.Image); //MetaData
Assert.AreEqual("Hello", codeOutput.Data.TextPlain.Text); //Data
}
public void TestMarkdownCell()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""markdown"",
""metadata"": {
},
""source"": [
""___\n"",
""\n"",
""<a href='http://www.pieriandata.com'> <img src='../Pierian_Data_Logo.png' /></a>\n"",
""___\n"",
""# Python Crash Course\n"",
]
}]
}";
var document = Jupyter.Parse(jupyterText);
var markdownCell = document.Cells.FirstOrDefault() as MarkdownCell;
Assert.AreEqual(CellType.Markdown, markdownCell.CellType); //Type
Assert.AreEqual(typeof(JObject), markdownCell.Metadata.GetType()); //Metadata
Assert.AreEqual(4, markdownCell.MarkdownDocument.Count); //Text
Assert.IsTrue(markdownCell.MarkdownDocument.LastOrDefault() is HeadingBlock); //Text
}
public void TestCodeCellStreamOutput()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""code"",
""execution_count"": 22,
""metadata"": {},
""outputs"": [
{
""name"": ""stdout"",
""output_type"": ""stream"",
""text"": [
""hello\n""
]
}
],
""source"": [
""print(x)""
]
}
]
}";
var document = Jupyter.Parse(jupyterText);
var codeCell = document.Cells.FirstOrDefault() as CodeCell;
var streamOutput = codeCell.Outputs.FirstOrDefault() as StreamOutput;
Assert.AreEqual(OutputType.Stream, streamOutput.OutputType); //Type
Assert.AreEqual("stdout", streamOutput.Name); //Name
Assert.AreEqual(1, streamOutput.Text.Count()); //Text
Assert.AreEqual("hello", streamOutput.Text.LastOrDefault()); //Text
}
public void TestCodeCell()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""code"",
""execution_count"": 7,
""metadata"": {},
""outputs"": [
{
""data"": {
""text/plain"": [
""3""
]
},
""execution_count"": 7,
""metadata"": {},
""output_type"": ""execute_result""
}
],
""source"": [
""1 * 3""
]
}]
}";
var document = Jupyter.Parse(jupyterText);
var codeCell = document.Cells.FirstOrDefault() as CodeCell;
Assert.AreEqual(CellType.Code, codeCell.CellType); //Type
Assert.AreEqual(7, codeCell.ExecutionCount); //ExecutionCount
Assert.AreEqual(false, codeCell.MetaData.Collapsed); //MetaData
Assert.AreEqual(false, codeCell.MetaData.AutoScroll); //MetaData
Assert.AreEqual(1, codeCell.Source.Count()); //Source
Assert.AreEqual("1 * 3", codeCell.Source.LastOrDefault()); //Source
}
public IActionResult PreviewHtml(JupyterPreviewModel model)
{
if (string.IsNullOrEmpty(model.SelectedItem))
{
return(RedirectToAction("Index"));
}
var jupyterText = model.PreviewJson;
if (!string.IsNullOrEmpty(jupyterText))
{
//convert to document
var document = Jupyter.Parse(jupyterText);
string htmlText = null;
using (var memoryStream = new MemoryStream())
{
using (var writer = new StreamWriter(memoryStream))
{
var htmlRenderer = new HtmlRenderer(writer)
{
RendererHeaderAndFooter = true,
CssText = GetCssFromSelection(model.SelectedItem)
};
htmlRenderer.Render(document);
}
htmlText = Encoding.UTF8.GetString(memoryStream.ToArray());
}
//preview
return(Content(htmlText, "text/html", Encoding.UTF8));
}
return(RedirectToAction("Index"));
}
public void TestReadingJpyterDocument1()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("Discover Sentiments in Tweets.ipynb");
var document = Jupyter.Parse(jupyterText);
//convert to html and open
ConvertDocumentToHtmlFile(document, "Discover Sentiments in Tweets.pdf", false);
}
public void TestReadingJpyterDocument2()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("01-Python Crash Course.ipynb");
var document = Jupyter.Parse(jupyterText);
//convert to html and open
ConvertDocumentToHtmlFile(document, "01-Python Crash Course.pdf", false);
}
public void TestMetadata()
{
var jupyterText = @"{
""metadata"": {
""kernelspec"": {
""display_name"": ""Python 3"",
""language"": ""python"",
""name"": ""python3""
},
""language_info"": {
""codemirror_mode"": {
""name"": ""ipython"",
""version"": 3
},
""file_extension"": "".py"",
""mimetype"": ""text/x-python"",
""name"": ""python"",
""nbconvert_exporter"": ""python"",
""pygments_lexer"": ""ipython3"",
""version"": ""3.6.2""
}
},
""nbformat"": 4,
""nbformat_minor"": 1
}";
var document = Jupyter.Parse(jupyterText);
var kernelSpec = document.Metadata.KernelSpec;
var kernelInfo = document.Metadata.KernelInfo;
var languageInfo = document.Metadata.LanguageInfo;
//Spec
Assert.AreEqual("Python 3", kernelSpec.DisplayName);
Assert.AreEqual("python", kernelSpec.Language);
Assert.AreEqual("python3", kernelSpec.Name);
//KernelInfo
Assert.AreEqual((object)null, kernelInfo.Name);
//LanguageInfo
Assert.AreEqual("ipython", languageInfo.CodemirrorMode.Name);
Assert.AreEqual("3", languageInfo.CodemirrorMode.Version);
Assert.AreEqual(".py", languageInfo.FileExtension);
Assert.AreEqual("text/x-python", languageInfo.MimeType);
Assert.AreEqual("python", languageInfo.Name);
Assert.AreEqual("python", languageInfo.NbconvertExporter);
Assert.AreEqual("ipython3", languageInfo.PygmentsLexer);
Assert.AreEqual("3.6.2", languageInfo.Version);
//NbFormat
Assert.AreEqual(4, document.NbFormat);
//NbFormatMinor
Assert.AreEqual(1, document.NbFormatMinor);
}
public IActionResult Preview(IFormFile file)
{
if (file == null)
{
ModelState.AddModelError("Error!", "File is empty.");
return(StatusCode(400));
}
if (!file.FileName.EndsWith(".ipynb"))
{
ModelState.AddModelError("Error!", "Upload Jupyter document file.");
return(StatusCode(400));
}
try
{
//get jupyter document raw text
var jupyterString = string.Empty;
using (var reader = new StreamReader(file.OpenReadStream()))
{
jupyterString = reader.ReadToEnd();
}
//convert to document
var document = Jupyter.Parse(jupyterString);
//Html text
var htmlText = "";
using (var memoryStream = new MemoryStream())
{
using (var writer = new StreamWriter(memoryStream))
{
var htmlRenderer = new HtmlRenderer(writer);
htmlRenderer.Render(document);
writer.Flush();
}
htmlText = Encoding.UTF8.GetString(memoryStream.ToArray());
}
//return view
return(View(new JupyterPreviewModel
{
StyleSelections = SelectListItemHelpers.EnumDropDownList(JupyterStyle.Chesterish),
PreviewHtml = htmlText,
PreviewJson = jupyterString
}));
}
catch (Exception e)
{
Console.WriteLine(e);
ModelState.AddModelError("Error!", "Error occurred while pharsing the file");
return(RedirectToAction("Index"));
}
}
public void TestReadingJpyterDocument2()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("01-Python Crash Course.ipynb");
var document = Jupyter.Parse(jupyterText);
//convert to json
var documentJson = ConvertDocumentToJson(document);
//convert to document again
var document2 = Jupyter.Parse(documentJson);
//Two class's property should be equal
Assert.IsTrue(CompareHelper.CompareWithJsonFormat(document, document2));
}
public void TestReadingJpyterDocument1()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("Discover Sentiments in Tweets.ipynb");
var document = Jupyter.Parse(jupyterText);
//convert to json
var documentJson = ConvertDocumentToJson(document);
//convert to document again
var document2 = Jupyter.Parse(documentJson);
//Two class's property should be equal
Assert.IsTrue(CompareHelper.CompareWithJsonFormat(document, document2));
//Change name
document2.Metadata.KernelInfo.Name = "AAAA";
//Should not equal
Assert.IsFalse(CompareHelper.CompareWithJsonFormat(document, document2));
}
public void TestCodeCellErrorOutput()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""code"",
""execution_count"": 44,
""metadata"": {},
""outputs"": [
{
""ename"": ""TypeError"",
""evalue"": ""'tuple' object does not support item assignment"",
""output_type"": ""error"",
""traceback"": [
""\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"",
""\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)"",
""\u001b[0;32m<ipython-input-44-97e4e33b36c2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'NEW'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m"",
""\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment""
]
}
],
""source"": [
""t[0] = 'NEW'""
]
}
]
}";
var documentText = Jupyter.Parse(jupyterText);
var codeCell = documentText.Cells.FirstOrDefault() as CodeCell;
var errorOutput = codeCell.Outputs.FirstOrDefault() as ErrorOutput;
Assert.AreEqual(OutputType.Error, errorOutput.OutputType); //Type
Assert.AreEqual("TypeError", errorOutput.Ename); //Ename
Assert.AreEqual("'tuple' object does not support item assignment", errorOutput.Evalue); //Evalue
Assert.AreEqual(4, errorOutput.Traceback.Count()); //Data
Assert.AreEqual(true,
errorOutput.Traceback.LastOrDefault()
.Contains("'tuple' object does not support item assignment")); //Source
}
public void TestCodeCellDisplayDataOutput()
{
var jupyterText = @"{
""cells"": [
{
""cell_type"": ""code"",
""execution_count"": 7,
""metadata"": {
""scrolled"": true,
""collapsed"": false
},
""outputs"": [
{
""output_type"": ""display_data"",
""data"": {
""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAT4AAAIXCAYAAAAFczJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1..."",
""text/plain"": ""<matplotlib.figure.Figure at 0x7f0ce3512320>""
},
""metadata"": {}
}
],
""source"": [
""1 * 3""
]
}]
}";
var document = Jupyter.Parse(jupyterText);
var codeCell = document.Cells.FirstOrDefault() as CodeCell;
var displayDataOutput = codeCell.Outputs.FirstOrDefault() as DisplayDataOutput;
Assert.AreEqual(OutputType.DisplayData, displayDataOutput.OutputType); //Type
Assert.AreEqual(
"iVBORw0KGgoAAAANSUhEUgAAAT4AAAIXCAYAAAAFczJTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1...",
displayDataOutput.Data.ImageData); //Data
Assert.AreEqual("<matplotlib.figure.Figure at 0x7f0ce3512320>",
displayDataOutput.Data.TextPlain.Text); //Data
Assert.AreEqual(null, displayDataOutput.MetaData.Image); //MetaData
}
public IActionResult DownloadToPdf(JupyterPreviewModel model)
{
var jupyterText = model.PreviewJson;
if (!string.IsNullOrEmpty(jupyterText))
{
//convert to document
var document = Jupyter.Parse(jupyterText);
//convert to html
string fileName = "jupyterDocument.pdf";
byte[] fileBytes = null;
using (var memoryStream = new MemoryStream())
{
var htmlRenderer = new PdfRenderer(memoryStream);
htmlRenderer.Render(document);
fileBytes = memoryStream.ToArray();
}
return(File(fileBytes, "application/force-download", fileName));
}
return(RedirectToAction("Index"));
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Demo demo = null,
TryGitHub tryGithub = null,
Pack pack = null,
Install install = null,
Verify verify = null,
Jupyter jupyter = null,
StartKernelServer startKernelServer = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
startServer = startServer ??
((startupOptions, invocationContext) =>
Program.ConstructWebHost(startupOptions).Run());
jupyter = jupyter ??
((startupOptions, console, server, context) =>
JupyterCommand.Do(startupOptions, console, server, context));
demo = demo ??
DemoCommand.Do;
tryGithub = tryGithub ??
((repo, console) =>
GitHubHandler.Handler(repo,
console,
new GitHubRepoLocator()));
verify = verify ??
((options, console, startupOptions) =>
VerifyCommand.Do(options,
console,
startupOptions));
pack = pack ??
PackCommand.Do;
install = install ??
InstallCommand.Do;
startKernelServer = startKernelServer ??
((startupOptions, kernel, console) =>
KernelServerCommand.Do(startupOptions, kernel, console));
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel = firstTimeUseNoticeSentinel ?? new FirstTimeUseNoticeSentinel();
// Setup telemetry.
telemetry = telemetry ?? new Telemetry.Telemetry(firstTimeUseNoticeSentinel);
var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
Action <ParseResult> track = o => telemetry.SendFiltered(filter, o);
var dirArgument = new Argument <FileSystemDirectoryAccessor>(() => new FileSystemDirectoryAccessor(Directory.GetCurrentDirectory()))
{
Name = nameof(StartupOptions.RootDirectory),
Arity = ArgumentArity.ZeroOrOne,
Description = "Specify the path to the root directory for your documentation",
};
dirArgument.AddValidator(symbolResult =>
{
var directory = symbolResult.Tokens
.Select(t => t.Value)
.FirstOrDefault();
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
{
return($"Directory does not exist: {directory}");
}
return(null);
});
var rootCommand = StartInTryMode();
rootCommand.AddCommand(StartInHostedMode());
rootCommand.AddCommand(Demo());
rootCommand.AddCommand(GitHub());
rootCommand.AddCommand(Pack());
rootCommand.AddCommand(Install());
rootCommand.AddCommand(Verify());
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(KernelServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
if (context.ParseResult.Directives.Contains("debug") &&
!(Clock.Current is VirtualClock))
{
VirtualClock.Start();
}
await next(context);
})
.Build());
RootCommand StartInTryMode()
{
var command = new RootCommand
{
Name = "dotnet-try",
Description = "Interactive documentation in your browser"
};
command.AddArgument(dirArgument);
command.AddOption(new Option(
"--add-package-source",
"Specify an additional NuGet package source")
{
Argument = new Argument <PackageSource>(() => new PackageSource(Directory.GetCurrentDirectory()))
{
Name = "NuGet source"
}
});
command.AddOption(new Option(
"--package",
"Specify a Try .NET package or path to a .csproj to run code samples with")
{
Argument = new Argument <string>
{
Name = "name or .csproj"
}
});
command.AddOption(new Option(
"--package-version",
"Specify a Try .NET package version to use with the --package option")
{
Argument = new Argument <string>
{
Name = "version"
}
});
command.AddOption(new Option(
"--uri",
"Specify a URL or a relative path to a Markdown file")
{
Argument = new Argument <Uri>()
});
command.AddOption(new Option(
"--enable-preview-features",
"Enable preview features")
{
Argument = new Argument <bool>()
});
command.AddOption(new Option(
"--log-path",
"Enable file logging to the specified directory")
{
Argument = new Argument <DirectoryInfo>
{
Name = "dir"
}
});
command.AddOption(new Option(
"--verbose",
"Enable verbose logging to the console")
{
Argument = new Argument <bool>()
});
var portArgument = new Argument <ushort>();
portArgument.AddValidator(symbolResult =>
{
if (symbolResult.Tokens
.Select(t => t.Value)
.Count(value => !ushort.TryParse(value, out _)) > 0)
{
return("Invalid argument for --port option");
}
return(null);
});
command.AddOption(new Option(
"--port",
"Specify the port for dotnet try to listen on")
{
Argument = portArgument
});
command.Handler = CommandHandler.Create <InvocationContext, StartupOptions>((context, options) =>
{
services.AddSingleton(_ => PackageRegistry.CreateForTryMode(
options.RootDirectory,
options.AddPackageSource));
startServer(options, context);
});
return(command);
}
Command StartInHostedMode()
{
var command = new Command("hosted")
{
new Option(
"--id",
"A unique id for the agent instance (e.g. its development environment id).")
{
Argument = new Argument <string>(defaultValue: () => Environment.MachineName)
},
new Option(
"--production",
"Specifies whether the agent is being run using production resources")
{
Argument = new Argument <bool>()
},
new Option(
"--language-service",
"Specifies whether the agent is being run in language service-only mode")
{
Argument = new Argument <bool>()
},
new Option(
new[]
{
"-k",
"--key"
},
"The encryption key")
{
Argument = new Argument <string>()
},
new Option(
new[]
{
"--ai-key",
"--application-insights-key"
},
"Application Insights key.")
{
Argument = new Argument <string>()
},
new Option(
"--region-id",
"A unique id for the agent region")
{
Argument = new Argument <string>()
},
new Option(
"--log-to-file",
"Writes a log file")
{
Argument = new Argument <bool>()
}
};
command.Description = "Starts the Try .NET agent";
command.IsHidden = true;
command.Handler = CommandHandler.Create <InvocationContext, StartupOptions>((context, options) =>
{
services.AddSingleton(_ => PackageRegistry.CreateForHostedMode());
services.AddSingleton(c => new MarkdownProject(c.GetRequiredService <PackageRegistry>()));
services.AddSingleton <IHostedService, Warmup>();
startServer(options, context);
});
return(command);
}
Command Demo()
{
var demoCommand = new Command(
"demo",
"Learn how to create Try .NET content with an interactive demo")
{
new Option("--output", "Where should the demo project be written to?")
{
Argument = new Argument <DirectoryInfo>(
defaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory()))
}
};
demoCommand.Handler = CommandHandler.Create <DemoOptions, InvocationContext>((options, context) =>
{
demo(options, context.Console, startServer, context);
});
return(demoCommand);
}
Command GitHub()
{
var argument = new Argument <string>
{
// System.CommandLine parameter binding does lookup by name,
// so name the argument after the github command's string param
Name = nameof(TryGitHubOptions.Repo)
};
var github = new Command("github", "Try a GitHub repo")
{
argument
};
github.IsHidden = true;
github.Handler = CommandHandler.Create <TryGitHubOptions, IConsole>((repo, console) => tryGithub(repo, console));
return(github);
}
Command Jupyter()
{
var jupyterCommand = new Command("jupyter", "Starts dotnet try as a Jupyter kernel");
var defaultKernelOption = new Option("--default-kernel", "The default .NET kernel language for the notebook.")
{
Argument = new Argument <string>(defaultValue: () => "csharp")
};
jupyterCommand.AddOption(defaultKernelOption);
var connectionFileArgument = new Argument <FileInfo>
{
Name = "ConnectionFile",
Arity = ArgumentArity.ZeroOrOne //should be removed once the commandlineapi allows subcommands to not have arguments from the main command
}.ExistingOnly();
jupyterCommand.AddArgument(connectionFileArgument);
jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext>((startupOptions, options, console, context) =>
{
track(context.ParseResult);
services
.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(
c =>
{
return(CommandScheduler
.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => CreateKernel(options.DefaultKernel))
.AddSingleton(c => new JupyterRequestContextHandler(c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
});
var installCommand = new Command("install", "Install the .NET kernel for Jupyter");
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext>((console, context) =>
{
track(context.ParseResult);
return(new JupyterCommandLine(console, new FileSystemJupyterKernelSpec()).InvokeAsync());
});
jupyterCommand.AddCommand(installCommand);
return(jupyterCommand);
}
Command KernelServer()
{
var startKernelServerCommand = new Command("kernel-server", "Starts dotnet-try with kernel functionality exposed over standard I/O");
var defaultKernelOption = new Option("--default-kernel", "The default .NET kernel language for the notebook.")
{
Argument = new Argument <string>(defaultValue: () => "csharp")
};
startKernelServerCommand.AddOption(defaultKernelOption);
startKernelServerCommand.Handler = CommandHandler.Create <StartupOptions, KernelServerOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
track(context.ParseResult);
return(startKernelServer(startupOptions, CreateKernel(options.DefaultKernel), console));
});
return(startKernelServerCommand);
}
Command Pack()
{
var packCommand = new Command("pack", "Create a Try .NET package")
{
new Argument <DirectoryInfo>
{
Name = nameof(PackOptions.PackTarget)
},
new Option("--version", "The version of the Try .NET package")
{
Argument = new Argument <string>()
},
new Option("--enable-wasm", "Enables web assembly code execution")
};
packCommand.IsHidden = true;
packCommand.Handler = CommandHandler.Create <PackOptions, IConsole>(
(options, console) =>
{
return(pack(options, console));
});
return(packCommand);
}
Command Install()
{
var installCommand = new Command("install", "Install a Try .NET package")
{
new Argument <string>
{
Name = nameof(InstallOptions.PackageName),
Arity = ArgumentArity.ExactlyOne
},
new Option("--add-source")
{
Argument = new Argument <PackageSource>()
}
};
installCommand.IsHidden = true;
installCommand.Handler = CommandHandler.Create <InstallOptions, IConsole>((options, console) => install(options, console));
return(installCommand);
}
Command Verify()
{
var verifyCommand = new Command("verify", "Verify Markdown files in the target directory and its children.")
{
dirArgument
};
verifyCommand.Handler = CommandHandler.Create <VerifyOptions, IConsole, StartupOptions>(
(options, console, startupOptions) =>
{
return(verify(options, console, startupOptions));
});
return(verifyCommand);
}
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartKernelServer startKernelServer = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
startServer ??= ((startupOptions, invocationContext) =>
Program.ConstructWebHost(startupOptions).Run());
jupyter ??= JupyterCommand.Do;
startKernelServer ??= (async(startupOptions, kernel, console) =>
{
var disposable = Program.StartToolLogging(startupOptions);
if (kernel is KernelBase kernelBase)
{
kernelBase.RegisterForDisposal(disposable);
}
var server = new StandardIOKernelServer(
kernel,
Console.In,
Console.Out);
await server.Input.LastAsync();
});
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel);
var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
void Track(ParseResult o) => telemetry.SendFiltered(filter, o);
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(KernelServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddOption(logPathOption);
command.AddOption(verboseOption);
return(command);
}
Command Jupyter()
{
var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
logPathOption,
verboseOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext>((startupOptions, options, console, context) =>
{
Track(context.ParseResult);
services
.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(
c =>
{
return(CommandScheduler
.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => CreateKernel(options.DefaultKernel))
.AddSingleton(c => new JupyterRequestContextHandler(c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
});
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
logPathOption,
verboseOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext>((console, context) =>
{
Track(context.ParseResult);
return(new JupyterInstallCommand(console, new JupyterKernelSpec()).InvokeAsync());
});
jupyterCommand.AddCommand(installCommand);
return(jupyterCommand);
}
Command KernelServer()
{
var startKernelServerCommand = new Command("kernel-server", "Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
logPathOption,
};
startKernelServerCommand.Handler = CommandHandler.Create <StartupOptions, KernelServerOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
Track(context.ParseResult);
return(startKernelServer(startupOptions, CreateKernel(options.DefaultKernel), console));
});
return(startKernelServerCommand);
}
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Demo demo = null,
TryGitHub tryGithub = null,
Pack pack = null,
Install install = null,
Verify verify = null,
Jupyter jupyter = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
startServer = startServer ??
((options, invocationContext) =>
Program.ConstructWebHost(options).Run());
jupyter = jupyter ??
JupyterCommand.Do;
demo = demo ??
DemoCommand.Do;
tryGithub = tryGithub ??
((repo, console) =>
GitHubHandler.Handler(repo,
console,
new GitHubRepoLocator()));
verify = verify ??
((verifyOptions, console, startupOptions) =>
VerifyCommand.Do(verifyOptions,
console,
() => new FileSystemDirectoryAccessor(verifyOptions.Dir),
PackageRegistry.CreateForTryMode(verifyOptions.Dir),
startupOptions));
pack = pack ??
PackCommand.Do;
install = install ??
InstallCommand.Do;
var dirArgument = new Argument <DirectoryInfo>
{
Arity = ArgumentArity.ZeroOrOne,
Name = nameof(StartupOptions.Dir).ToLower(),
Description = "Specify the path to the root directory for your documentation"
}.ExistingOnly();
var rootCommand = StartInTryMode();
rootCommand.AddCommand(StartInHostedMode());
rootCommand.AddCommand(Demo());
rootCommand.AddCommand(GitHub());
rootCommand.AddCommand(Pack());
rootCommand.AddCommand(Install());
rootCommand.AddCommand(Verify());
rootCommand.AddCommand(Jupyter());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
if (context.ParseResult.Directives.Contains("debug") &&
!(Clock.Current is VirtualClock))
{
VirtualClock.Start();
}
await next(context);
})
.Build());
RootCommand StartInTryMode()
{
var command = new RootCommand
{
Name = "dotnet-try",
Description = "Interactive documentation in your browser"
};
command.AddArgument(dirArgument);
command.AddOption(new Option(
"--add-package-source",
"Specify an additional NuGet package source")
{
Argument = new Argument <PackageSource>(() => new PackageSource(Directory.GetCurrentDirectory()))
{
Name = "NuGet source"
}
});
command.AddOption(new Option(
"--package",
"Specify a Try .NET package or path to a .csproj to run code samples with")
{
Argument = new Argument <string>
{
Name = "name or .csproj"
}
});
command.AddOption(new Option(
"--package-version",
"Specify a Try .NET package version to use with the --package option")
{
Argument = new Argument <string>
{
Name = "version"
}
});
command.AddOption(new Option(
"--uri",
"Specify a URL or a relative path to a Markdown file")
{
Argument = new Argument <Uri>()
});
command.AddOption(new Option(
"--enable-preview-features",
"Enable preview features")
{
Argument = new Argument <bool>()
});
command.AddOption(new Option(
"--log-path",
"Enable file logging to the specified directory")
{
Argument = new Argument <DirectoryInfo>
{
Name = "dir"
}
});
command.AddOption(new Option(
"--verbose",
"Enable verbose logging to the console")
{
Argument = new Argument <bool>()
});
var portArgument = new Argument <ushort>();
portArgument.AddValidator(symbolResult =>
{
if (symbolResult.Tokens
.Select(t => t.Value)
.Count(value => !ushort.TryParse(value, out _)) > 0)
{
return("Invalid argument for --port option");
}
return(null);
});
command.AddOption(new Option(
"--port",
"Specify the port for dotnet try to listen on")
{
Argument = portArgument
});
command.Handler = CommandHandler.Create <InvocationContext, StartupOptions>((context, options) =>
{
services.AddSingleton(_ => PackageRegistry.CreateForTryMode(
options.Dir,
options.AddPackageSource));
startServer(options, context);
});
return(command);
}
Command StartInHostedMode()
{
var command = new Command("hosted")
{
new Option(
"--id",
"A unique id for the agent instance (e.g. its development environment id).")
{
Argument = new Argument <string>(defaultValue: () => Environment.MachineName)
},
new Option(
"--production",
"Specifies whether the agent is being run using production resources")
{
Argument = new Argument <bool>()
},
new Option(
"--language-service",
"Specifies whether the agent is being run in language service-only mode")
{
Argument = new Argument <bool>()
},
new Option(
new[]
{
"-k",
"--key"
},
"The encryption key")
{
Argument = new Argument <string>()
},
new Option(
new[]
{
"--ai-key",
"--application-insights-key"
},
"Application Insights key.")
{
Argument = new Argument <string>()
},
new Option(
"--region-id",
"A unique id for the agent region")
{
Argument = new Argument <string>()
},
new Option(
"--log-to-file",
"Writes a log file")
{
Argument = new Argument <bool>()
}
};
command.Description = "Starts the Try .NET agent";
command.IsHidden = true;
command.Handler = CommandHandler.Create <InvocationContext, StartupOptions>((context, options) =>
{
services.AddSingleton(_ => PackageRegistry.CreateForHostedMode());
services.AddSingleton(c => new MarkdownProject(c.GetRequiredService <PackageRegistry>()));
services.AddSingleton <IHostedService, Warmup>();
startServer(options, context);
});
return(command);
}
Command Demo()
{
var demoCommand = new Command(
"demo",
"Learn how to create Try .NET content with an interactive demo")
{
new Option("--output", "Where should the demo project be written to?")
{
Argument = new Argument <DirectoryInfo>(
defaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory()))
}
};
demoCommand.Handler = CommandHandler.Create <DemoOptions, InvocationContext>((options, context) =>
{
demo(options, context.Console, startServer, context);
});
return(demoCommand);
}
Command GitHub()
{
var argument = new Argument <string>
{
// System.CommandLine parameter binding does lookup by name,
// so name the argument after the github command's string param
Name = nameof(TryGitHubOptions.Repo)
};
var github = new Command("github", "Try a GitHub repo")
{
argument
};
github.IsHidden = true;
github.Handler = CommandHandler.Create <TryGitHubOptions, IConsole>((repo, console) => tryGithub(repo, console));
return(github);
}
Command Jupyter()
{
var jupyterCommand = new Command("jupyter", "Starts dotnet try as a Jupyter kernel")
{
IsHidden = true
};
var connectionFileArgument = new Argument <FileInfo>
{
Name = "ConnectionFile"
}.ExistingOnly();
jupyterCommand.AddArgument(connectionFileArgument);
jupyterCommand.Handler = CommandHandler.Create <JupyterOptions, IConsole, InvocationContext>((options, console, context) =>
{
services
.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(
c =>
{
return(CommandScheduler
.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddTransient <IKernel>(c => new CompositeKernel
{
new CSharpKernel().UseNugetDirective()
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <PackageRegistry>(),
c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(options, console, startServer, context));
});
return(jupyterCommand);
}
Command Pack()
{
var packCommand = new Command("pack", "Create a Try .NET package")
{
new Argument <DirectoryInfo>
{
Name = nameof(PackOptions.PackTarget)
},
new Option("--version", "The version of the Try .NET package")
{
Argument = new Argument <string>()
},
new Option("--enable-wasm", "Enables web assembly code execution")
};
packCommand.IsHidden = true;
packCommand.Handler = CommandHandler.Create <PackOptions, IConsole>(
(options, console) =>
{
return(pack(options, console));
});
return(packCommand);
}
Command Install()
{
var installCommand = new Command("install", "Install a Try .NET package")
{
new Argument <string>
{
Name = nameof(InstallOptions.PackageName)
},
new Option("--add-source")
{
Argument = new Argument <PackageSource>()
}
};
installCommand.IsHidden = true;
installCommand.Handler = CommandHandler.Create <InstallOptions, IConsole>((options, console) => install(options, console));
return(installCommand);
}
Command Verify()
{
var verifyCommand = new Command("verify", "Verify Markdown files in the target directory and its children.")
{
dirArgument
};
verifyCommand.Handler = CommandHandler.Create <VerifyOptions, IConsole, StartupOptions>(
(options, console, startupOptions) =>
{
return(verify(options, console, startupOptions));
});
return(verifyCommand);
}
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartKernelHost startKernelHost = null,
StartNotebookParser startNotebookParser = null,
StartHttp startHttp = null,
Action onServerStarted = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
var operation = Log.OnEnterAndExit();
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
operation.Info("constructing webhost");
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
operation.Info("starting kestrel server");
webHost.Start();
onServerStarted?.Invoke();
webHost.WaitForShutdown();
operation.Dispose();
};
jupyter ??= JupyterCommand.Do;
startKernelHost ??= KernelHostLauncher.Do;
startNotebookParser ??= ParseNotebookCommand.Do;
startHttp ??= HttpCommand.Do;
var isVSCode = false;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
var clearTextProperties = new[]
{
"frontend"
};
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel,
"dotnet/interactive/cli");
var filter = new TelemetryFilter(
Sha256Hasher.HashWithNormalizedCasing,
clearTextProperties,
(commandResult, directives, entryItems) =>
{
// add frontend
var frontendTelemetryAdded = false;
// check if is codespaces
if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("CODESPACES")))
{
frontendTelemetryAdded = true;
isVSCode = true;
entryItems.Add(new KeyValuePair <string, string>("frontend", "gitHubCodeSpaces"));
}
if (!frontendTelemetryAdded)
{
foreach (var directive in directives)
{
switch (directive.Key)
{
case "jupyter":
case "synapse":
case "vscode":
frontendTelemetryAdded = true;
isVSCode = directive.Key.ToLowerInvariant() == "vscode";
entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key));
break;
}
}
}
if (!frontendTelemetryAdded)
{
switch (commandResult.Command.Name)
{
case "jupyter":
entryItems.Add(new KeyValuePair <string, string>("frontend", commandResult.Command.Name));
frontendTelemetryAdded = true;
break;
}
}
if (!frontendTelemetryAdded)
{
var frontendName = Environment.GetEnvironmentVariable("DOTNET_INTERACTIVE_FRONTEND_NAME");
if (string.IsNullOrWhiteSpace(frontendName))
{
frontendName = "unknown";
}
entryItems.Add(new KeyValuePair <string, string>("frontend", frontendName));
}
});
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp").AddCompletions("fsharp", "csharp", "pwsh");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(NotebookParser());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.AddMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!Telemetry.Telemetry.SkipFirstTimeExperience &&
!firstTimeUseNoticeSentinel.Exists())
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddGlobalOption(logPathOption);
command.AddGlobalOption(verboseOption);
return(command);
}
Command Jupyter()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services",
isDefault: true);
var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file",
Description = "The path to a connection file provided by Jupyter"
}.ExistingOnly()
};
jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler);
jupyterCommand.AddCommand(installCommand);
return(jupyterCommand);
async Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
var frontendEnvironment = new HtmlNotebookFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
kernel.Add(
new JavaScriptKernel(),
new[] { "js" });
services.AddKernel(kernel);
kernel.VisitSubkernels(k =>
{
switch (k)
{
case CSharpKernel csharpKernel:
csharpKernel.UseJupyterHelpers();
break;
case FSharpKernel fsharpKernel:
fsharpKernel.UseJupyterHelpers();
break;
case PowerShellKernel powerShellKernel:
powerShellKernel.UseJupyterHelpers();
break;
}
});
var clientSideKernelClient = new SignalRBackchannelKernelClient();
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(clientSideKernelClient)
.AddSingleton(c =>
{
return(new JupyterRequestContextScheduler(delivery => c.GetRequiredService <JupyterRequestContextHandler>()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(kernel))
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
var result = await jupyter(startupOptions, console, startServer, context);
return(result);
}
Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path)
{
var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path);
return(jupyterInstallCommand.InvokeAsync());
}
}
Command HttpServer()
{
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
},
isDefault: true);
var httpCommand = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption
};
httpCommand.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
kernel.Add(
new JavaScriptKernel(),
new[] { "js" });
services.AddKernel(kernel)
.AddSingleton(new SignalRBackchannelKernelClient());
onServerStarted ??= () =>
{
console.Out.WriteLine("Application started. Press Ctrl+C to shut down.");
};
return(startHttp(startupOptions, console, startServer, context));
});
return(httpCommand);
}
Command StdIO()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services");
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.FindResultFor(httpPortRangeOption) is { } conflictingOption)
{
var parsed = result.Parent as OptionResult;
result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together";
return(null);
}
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
});
var workingDirOption = new Option <DirectoryInfo>(
"--working-dir",
() => new DirectoryInfo(Environment.CurrentDirectory),
"Working directory to which to change after launching the kernel.");
var stdIOCommand = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption,
httpPortOption,
workingDirOption
};
stdIOCommand.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext>(
async(startupOptions, options, console, context) =>
{
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
Environment.CurrentDirectory = startupOptions.WorkingDir.FullName;
FrontendEnvironment frontendEnvironment = startupOptions.EnableHttpApi
? new HtmlNotebookFrontendEnvironment()
: new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
services.AddKernel(kernel);
kernel = kernel.UseQuitCommand();
var host = new KernelHost(kernel, new KernelCommandAndEventTextStreamSender(Console.Out),
new MultiplexingKernelCommandAndEventReceiver(
new KernelCommandAndEventTextReceiver(Console.In)));
if (isVSCode)
{
var vscodeSetup = new VSCodeClientKernelsExtension();
await vscodeSetup.OnLoadAsync(kernel);
}
if (startupOptions.EnableHttpApi)
{
var clientSideKernelClient = new SignalRBackchannelKernelClient();
services.AddSingleton(clientSideKernelClient);
if (isVSCode)
{
((HtmlNotebookFrontendEnvironment)frontendEnvironment).RequiresAutomaticBootstrapping = false;
}
else
{
kernel.Add(
new JavaScriptKernel(clientSideKernelClient),
new[] { "js" });
}
onServerStarted ??= () =>
{
var _ = host.ConnectAsync();
};
await startHttp(startupOptions, console, startServer, context);
}
else
{
if (!isVSCode)
{
await host.CreateProxyKernelOnDefaultConnectorAsync(new KernelInfo("javascript", "javascript")
{
Aliases = new[] { "js" },
DestinationUri = new Uri("kernel://webview/javascript")
});
}
await startKernelHost(startupOptions, host, console);
}
return(0);
});
return(stdIOCommand);
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
StartHttp startHttp = null,
Action onServerStarted = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
var operation = Log.OnEnterAndExit();
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
operation.Info("constructing webhost");
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
operation.Info("starting kestrel server");
webHost.Start();
onServerStarted?.Invoke();
webHost.WaitForShutdown();
operation.Dispose();
};
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
startHttp ??= HttpCommand.Do;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
var clearTextProperties = new[]
{
"frontend"
};
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel,
"dotnet/interactive/cli");
var filter = new TelemetryFilter(
Sha256Hasher.HashWithNormalizedCasing,
clearTextProperties,
(commandResult, directives, entryItems) =>
{
// add frontend
var frontendTelemetryAdded = false;
foreach (var directive in directives)
{
switch (directive.Key)
{
case "vscode":
case "jupyter":
case "synapse":
frontendTelemetryAdded = true;
entryItems.Add(new KeyValuePair <string, string>("frontend", directive.Key));
break;
}
}
if (!frontendTelemetryAdded)
{
if (commandResult.Command.Name == "jupyter")
{
entryItems.Add(new KeyValuePair <string, string>("frontend", "jupyter"));
}
else
{
entryItems.Add(new KeyValuePair <string, string>("frontend", "unknown"));
}
}
});
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!Telemetry.Telemetry.SkipFirstTimeExperience &&
!firstTimeUseNoticeSentinel.Exists())
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddGlobalOption(logPathOption);
command.AddGlobalOption(verboseOption);
return(command);
}
Command Jupyter()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services",
isDefault: true);
var jupyterCommand = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
jupyterCommand.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler);
jupyterCommand.AddCommand(installCommand);
return(jupyterCommand);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
var frontendEnvironment = new HtmlNotebookFrontedEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
services.AddKernel(kernel);
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(c =>
{
return(new JupyterRequestContextScheduler(delivery => c.GetRequiredService <JupyterRequestContextHandler>()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(kernel))
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path)
{
var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path);
return(jupyterInstallCommand.InvokeAsync());
}
}
Command HttpServer()
{
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
},
isDefault: true);
var httpCommand = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption
};
httpCommand.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
services.AddKernel(kernel);
onServerStarted ??= () =>
{
console.Out.WriteLine("Application started. Press Ctrl+C to shut down.");
};
return(startHttp(startupOptions, console, startServer, context));
});
return(httpCommand);
}
Command StdIO()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services");
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.FindResultFor(httpPortRangeOption) is { } conflictingOption)
{
var parsed = result.Parent as OptionResult;
result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together";
return(null);
}
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
});
var workingDirOption = new Option <DirectoryInfo>(
"--working-dir",
() => new DirectoryInfo(Environment.CurrentDirectory),
"Working directory to which to change after launching the kernel.");
var stdIOCommand = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption,
httpPortOption,
workingDirOption
};
stdIOCommand.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext, CancellationToken>(
(startupOptions, options, console, context, cancellationToken) =>
{
FrontendEnvironment frontendEnvironment = startupOptions.EnableHttpApi
? new HtmlNotebookFrontedEnvironment()
: new BrowserFrontendEnvironment();
var kernel = CreateKernel(options.DefaultKernel, frontendEnvironment, startupOptions);
services.AddKernel(kernel);
kernel.UseQuitCommand(disposeOnQuit, cancellationToken);
var kernelServer = kernel.CreateKernelServer(startupOptions.WorkingDir);
if (startupOptions.EnableHttpApi)
{
if (context.ParseResult.Directives.Contains("vscode"))
{
((HtmlNotebookFrontedEnvironment)frontendEnvironment).RequiresAutomaticBootstrapping =
false;
}
kernelServer.Start();
onServerStarted ??= () =>
{
kernelServer.NotifyIsReady();
};
return(startHttp(startupOptions, console, startServer, context));
}
disposeOnQuit.Add(kernel);
return(startStdIO(
startupOptions,
kernelServer,
console));
});
return(stdIOCommand);
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
startServer ??= (startupOptions, invocationContext) =>
Program.ConstructWebHost(startupOptions).Run();
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel);
var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
});
var httpPortRangeOption = new Option <PortRange>(
"--http-port-range",
parseArgument: result =>
{
if (result.Parent.Parent.Children.FirstOrDefault(c => c.Symbol == httpPortOption) is OptionResult conflictingOption)
{
var parsed = result.Parent as OptionResult;
result.ErrorMessage = $"Cannot specify both {conflictingOption.Token.Value} and {parsed.Token.Value} together";
return(null);
}
var source = result.Tokens[0].Value;
if (string.IsNullOrWhiteSpace(source))
{
result.ErrorMessage = "Must specify a port range";
return(null);
}
var parts = source.Split(new[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
result.ErrorMessage = "Must specify a port range";
return(null);
}
if (!int.TryParse(parts[0], out var start) || !int.TryParse(parts[1], out var end))
{
result.ErrorMessage = "Must specify a port range as StartPort-EndPort";
return(null);
}
if (start > end)
{
result.ErrorMessage = "Start port must be lower then end port";
return(null);
}
var pr = new PortRange(start, end);
return(pr);
},
description: "Specifies the range of port to use to enable HTTP services");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddOption(logPathOption);
command.AddOption(verboseOption);
return(command);
}
Command Jupyter()
{
var command = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
logPathOption,
verboseOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
command.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
logPathOption,
verboseOption,
httpPortRangeOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, PortRange, DirectoryInfo>(InstallHandler);
command.AddCommand(installCommand);
return(command);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context)
{
services = RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel);
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton <FrontendEnvironment>(c => c.GetService <BrowserFrontendEnvironment>())
.AddSingleton(c =>
{
return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
Task <int> InstallHandler(IConsole console, InvocationContext context, PortRange httpPortRange, DirectoryInfo location) =>
new JupyterInstallCommand(console, jupyterKernelSpecInstaller: new JupyterKernelSpecInstaller(console), httpPortRange, location).InvokeAsync();
}
Command HttpServer()
{
var command = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption,
logPathOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
if (startupOptions.HttpPort == null && startupOptions.HttpPortRange == null)
{
startupOptions.HttpPort = HttpPort.Auto;
}
RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel);
return(jupyter(startupOptions, console, startServer, context));
});
return(command);
}
Command StdIO()
{
var command = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
logPathOption,
httpPortOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
if (startupOptions.EnableHttpApi)
{
RegisterKernelInServiceCollection(services, startupOptions, options.DefaultKernel,
kernel => StdIOCommand.CreateServer(kernel, console));
startServer?.Invoke(startupOptions, context);
return(Task.FromResult(0));
}
return(startStdIO(
startupOptions,
CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(), startupOptions, null),
console));
});
return(command);
}
}
public static Parser Create(
IServiceCollection services,
StartServer startServer = null,
Jupyter jupyter = null,
StartStdIO startStdIO = null,
StartHttp startHttp = null,
ITelemetry telemetry = null,
IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var disposeOnQuit = new CompositeDisposable();
startServer ??= (startupOptions, invocationContext) =>
{
var webHost = Program.ConstructWebHost(startupOptions);
disposeOnQuit.Add(webHost);
webHost.Run();
};
jupyter ??= JupyterCommand.Do;
startStdIO ??= StdIOCommand.Do;
startHttp ??= HttpCommand.Do;
// Setup first time use notice sentinel.
firstTimeUseNoticeSentinel ??= new FirstTimeUseNoticeSentinel(VersionSensor.Version().AssemblyInformationalVersion);
// Setup telemetry.
telemetry ??= new Telemetry.Telemetry(
VersionSensor.Version().AssemblyInformationalVersion,
firstTimeUseNoticeSentinel);
var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
var verboseOption = new Option <bool>(
"--verbose",
"Enable verbose logging to the console");
var logPathOption = new Option <DirectoryInfo>(
"--log-path",
"Enable file logging to the specified directory");
var pathOption = new Option <DirectoryInfo>(
"--path",
"Installs the kernelspecs to the specified directory")
.ExistingOnly();
var defaultKernelOption = new Option <string>(
"--default-kernel",
description: "The default language for the kernel",
getDefaultValue: () => "csharp");
var rootCommand = DotnetInteractive();
rootCommand.AddCommand(Jupyter());
rootCommand.AddCommand(StdIO());
rootCommand.AddCommand(HttpServer());
return(new CommandLineBuilder(rootCommand)
.UseDefaults()
.UseMiddleware(async(context, next) =>
{
if (context.ParseResult.Errors.Count == 0)
{
telemetry.SendFiltered(filter, context.ParseResult);
}
// If sentinel does not exist, print the welcome message showing the telemetry notification.
if (!firstTimeUseNoticeSentinel.Exists() && !Telemetry.Telemetry.SkipFirstTimeExperience)
{
context.Console.Out.WriteLine();
context.Console.Out.WriteLine(Telemetry.Telemetry.WelcomeMessage);
firstTimeUseNoticeSentinel.CreateIfNotExists();
}
await next(context);
})
.Build());
RootCommand DotnetInteractive()
{
var command = new RootCommand
{
Name = "dotnet-interactive",
Description = "Interactive programming for .NET."
};
command.AddOption(logPathOption);
command.AddOption(verboseOption);
return(command);
}
Command Jupyter()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services",
isDefault: true);
var command = new Command("jupyter", "Starts dotnet-interactive as a Jupyter kernel")
{
defaultKernelOption,
logPathOption,
verboseOption,
httpPortRangeOption,
new Argument <FileInfo>
{
Name = "connection-file"
}.ExistingOnly()
};
command.Handler = CommandHandler.Create <StartupOptions, JupyterOptions, IConsole, InvocationContext, CancellationToken>(JupyterHandler);
var installCommand = new Command("install", "Install the .NET kernel for Jupyter")
{
httpPortRangeOption,
logPathOption,
verboseOption,
pathOption
};
installCommand.Handler = CommandHandler.Create <IConsole, InvocationContext, HttpPortRange, DirectoryInfo>(InstallHandler);
command.AddCommand(installCommand);
return(command);
Task <int> JupyterHandler(StartupOptions startupOptions, JupyterOptions options, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
services = RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
});
services.AddSingleton(c => ConnectionInformation.Load(options.ConnectionFile))
.AddSingleton(c =>
{
return(CommandScheduler.Create <JupyterRequestContext>(delivery => c.GetRequiredService <ICommandHandler <JupyterRequestContext> >()
.Trace()
.Handle(delivery)));
})
.AddSingleton(c => new JupyterRequestContextHandler(
c.GetRequiredService <IKernel>())
.Trace())
.AddSingleton <IHostedService, Shell>()
.AddSingleton <IHostedService, Heartbeat>();
return(jupyter(startupOptions, console, startServer, context));
}
Task <int> InstallHandler(IConsole console, InvocationContext context, HttpPortRange httpPortRange, DirectoryInfo path)
{
var jupyterInstallCommand = new JupyterInstallCommand(console, new JupyterKernelSpecInstaller(console), httpPortRange, path);
return(jupyterInstallCommand.InvokeAsync());
}
}
Command HttpServer()
{
var httpPortOption = new Option <HttpPort>(
"--http-port",
description: "Specifies the port on which to enable HTTP services",
parseArgument: result =>
{
if (result.Tokens.Count == 0)
{
return(HttpPort.Auto);
}
var source = result.Tokens[0].Value;
if (source == "*")
{
return(HttpPort.Auto);
}
if (!int.TryParse(source, out var portNumber))
{
result.ErrorMessage = "Must specify a port number or *.";
return(null);
}
return(new HttpPort(portNumber));
},
isDefault: true);
var command = new Command("http", "Starts dotnet-interactive with kernel functionality exposed over http")
{
defaultKernelOption,
httpPortOption,
logPathOption
};
command.Handler = CommandHandler.Create <StartupOptions, KernelHttpOptions, IConsole, InvocationContext>(
(startupOptions, options, console, context) =>
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ =>
{
var frontendEnvironment = new BrowserFrontendEnvironment();
return(frontendEnvironment);
});
serviceCollection.AddSingleton <FrontendEnvironment>(c => c.GetRequiredService <BrowserFrontendEnvironment>());
});
return(startHttp(startupOptions, console, startServer, context));
});
return(command);
}
Command StdIO()
{
var httpPortRangeOption = new Option <HttpPortRange>(
"--http-port-range",
parseArgument: result => result.Tokens.Count == 0 ? HttpPortRange.Default : ParsePortRangeOption(result),
description: "Specifies the range of ports to use to enable HTTP services");
var command = new Command(
"stdio",
"Starts dotnet-interactive with kernel functionality exposed over standard I/O")
{
defaultKernelOption,
httpPortRangeOption
};
command.Handler = CommandHandler.Create <StartupOptions, StdIOOptions, IConsole, InvocationContext, CancellationToken>(
(startupOptions, options, console, context, cancellationToken) =>
{
if (startupOptions.EnableHttpApi)
{
RegisterKernelInServiceCollection(
services,
startupOptions,
options.DefaultKernel,
serviceCollection =>
{
serviceCollection.AddSingleton(_ => new HtmlNotebookFrontedEnvironment());
serviceCollection.AddSingleton <FrontendEnvironment>(c =>
c.GetService <HtmlNotebookFrontedEnvironment>());
}, kernel =>
{
StdIOCommand.CreateServer(kernel, console);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
});
return(startHttp(startupOptions, console, startServer, context));
}
{
var kernel = CreateKernel(options.DefaultKernel, new BrowserFrontendEnvironment(),
startupOptions);
disposeOnQuit.Add(kernel);
kernel.UseQuiCommand(disposeOnQuit, cancellationToken);
return(startStdIO(
startupOptions,
kernel,
console));
}
});
return(command);
}
