/// <summary>
/// Creates a virtual environment. If virtualenv or pip are not
/// installed then they are downloaded and installed automatically.
/// </summary>
public static async Task CreateAndInstallDependencies(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string path,
Redirector output = null
)
{
factory.ThrowIfNotRunnable("factory");
var modules = await factory.FindModulesAsync("pip", "virtualenv", "venv");
bool hasPip = modules.Contains("pip");
bool hasVirtualEnv = modules.Contains("virtualenv") || modules.Contains("venv");
if (!hasVirtualEnv)
{
if (!hasPip)
{
bool elevate = provider.GetPythonToolsService().GeneralOptions.ElevatePip;
await Pip.InstallPip(provider, factory, elevate, output);
}
if (!await Install(provider, factory, output))
{
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
await ContinueCreate(provider, factory, path, false, output);
}
private static async Task<IPythonInterpreterFactory> TryGetCondaFactoryAsync(
IPythonInterpreterFactory target,
IInterpreterOptionsService service
) {
var condaMetaPath = CommonUtils.GetAbsoluteDirectoryPath(
target.Configuration.PrefixPath,
"conda-meta"
);
if (!Directory.Exists(condaMetaPath)) {
return null;
}
string metaFile;
try {
metaFile = Directory.EnumerateFiles(condaMetaPath, "*.json").FirstOrDefault();
} catch (Exception ex) {
if (ex.IsCriticalException()) {
throw;
}
return null;
}
if (!string.IsNullOrEmpty(metaFile)) {
string text = string.Empty;
try {
text = File.ReadAllText(metaFile);
} catch (Exception ex) {
if (ex.IsCriticalException()) {
throw;
}
}
var m = Regex.Match(text, @"\{[^{]+link.+?\{.+?""source""\s*:\s*""(.+?)""", RegexOptions.Singleline);
if (m.Success) {
var pkg = m.Groups[1].Value;
if (!Directory.Exists(pkg)) {
return null;
}
var prefix = Path.GetDirectoryName(Path.GetDirectoryName(pkg));
var factory = service.Interpreters.FirstOrDefault(
f => CommonUtils.IsSameDirectory(f.Configuration.PrefixPath, prefix)
);
if (factory != null && !(await factory.FindModulesAsync("conda")).Any()) {
factory = null;
}
return factory;
}
}
if ((await target.FindModulesAsync("conda")).Any()) {
return target;
}
return null;
}
public static async Task <bool> Install(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string package,
bool elevate,
Redirector output = null
)
{
factory.ThrowIfNotRunnable("factory");
if (!(await factory.FindModulesAsync("pip")).Any())
{
await InstallPip(provider, factory, elevate, output);
}
using (var proc = Run(factory, output, elevate, "install", GetInsecureArg(factory, output), package)) {
await proc;
return(proc.ExitCode == 0);
}
}
/// <summary>
/// Creates a virtual environment. If virtualenv or pip are not
/// installed then they are downloaded and installed automatically.
/// </summary>
public static async Task CreateAndInstallDependencies(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string path
)
{
factory.ThrowIfNotRunnable("factory");
var cancel = CancellationToken.None;
var ui = new VsPackageManagerUI(provider);
var pm = factory.PackageManager;
if (pm == null)
{
throw new InvalidOperationException(Strings.PackageManagementNotSupported);
}
if (!pm.IsReady)
{
await pm.PrepareAsync(ui, cancel);
if (!pm.IsReady)
{
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
var modules = await factory.FindModulesAsync("virtualenv", "venv");
bool hasVirtualEnv = modules.Contains("virtualenv") || modules.Contains("venv");
if (!hasVirtualEnv)
{
if (!await Install(provider, factory))
{
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
await ContinueCreate(provider, factory, path, false, PackageManagerUIRedirector.Get(pm, ui));
}
/// <summary>
/// Creates a virtual environment. If virtualenv or pip are not
/// installed then they are downloaded and installed automatically.
/// </summary>
public static async Task CreateAndInstallDependencies(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string path,
Redirector output = null
) {
factory.ThrowIfNotRunnable("factory");
var modules = await factory.FindModulesAsync("pip", "virtualenv", "venv");
bool hasPip = modules.Contains("pip");
bool hasVirtualEnv = modules.Contains("virtualenv") || modules.Contains("venv");
if (!hasVirtualEnv) {
if (!hasPip) {
bool elevate = provider.GetPythonToolsService().GeneralOptions.ElevatePip;
await Pip.InstallPip(provider, factory, elevate, output);
}
if (!await Install(provider, factory, output)) {
throw new InvalidOperationException(SR.GetString(SR.VirtualEnvCreationFailed, path));
}
}
await ContinueCreate(provider, factory, path, false, output);
}
private static async Task <IPythonInterpreterFactory> TryGetCondaFactoryAsync(
IPythonInterpreterFactory target,
IInterpreterOptionsService service
)
{
var condaMetaPath = CommonUtils.GetAbsoluteDirectoryPath(
target.Configuration.PrefixPath,
"conda-meta"
);
if (!Directory.Exists(condaMetaPath))
{
return(null);
}
string metaFile;
try {
metaFile = Directory.EnumerateFiles(condaMetaPath, "*.json").FirstOrDefault();
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
return(null);
}
if (!string.IsNullOrEmpty(metaFile))
{
string text = string.Empty;
try {
text = File.ReadAllText(metaFile);
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
}
var m = Regex.Match(text, @"\{[^{]+link.+?\{.+?""source""\s*:\s*""(.+?)""", RegexOptions.Singleline);
if (m.Success)
{
var pkg = m.Groups[1].Value;
if (!Directory.Exists(pkg))
{
return(null);
}
var prefix = Path.GetDirectoryName(Path.GetDirectoryName(pkg));
var factory = service.Interpreters.FirstOrDefault(
f => CommonUtils.IsSameDirectory(f.Configuration.PrefixPath, prefix)
);
if (factory != null && !(await factory.FindModulesAsync("conda")).Any())
{
factory = null;
}
return(factory);
}
}
if ((await target.FindModulesAsync("conda")).Any())
{
return(target);
}
return(null);
}
public static async Task <bool> Install(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string package,
IServiceProvider site,
bool elevate,
Redirector output = null
)
{
factory.ThrowIfNotRunnable("factory");
if (!(await factory.FindModulesAsync("pip")).Any())
{
if (site != null)
{
try {
await QueryInstallPip(factory, site, Strings.InstallPip, elevate, output);
} catch (OperationCanceledException) {
return(false);
}
}
else
{
await InstallPip(provider, factory, elevate, output);
}
}
if (output != null)
{
output.WriteLine(Strings.PackageInstalling.FormatUI(package));
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation)
{
output.ShowAndActivate();
}
else
{
output.Show();
}
}
using (var proc = Run(factory, output, elevate, "install", GetInsecureArg(factory, output), package)) {
var exitCode = await proc;
if (output != null)
{
if (exitCode == 0)
{
output.WriteLine(Strings.PackageInstallSucceeded.FormatUI(package));
}
else
{
output.WriteLine(Strings.PackageInstallFailedExitCode.FormatUI(package, exitCode));
}
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation)
{
output.ShowAndActivate();
}
else
{
output.Show();
}
}
return(exitCode == 0);
}
}
public static HashSet <string> FindModules(this IPythonInterpreterFactory factory, params string[] moduleNames)
{
return(factory.FindModulesAsync(moduleNames).GetAwaiter().GetResult());
}
public static async Task<bool> Install(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string package,
IServiceProvider site,
bool elevate,
Redirector output = null
) {
factory.ThrowIfNotRunnable("factory");
if (!(await factory.FindModulesAsync("pip")).Any()) {
if (site != null) {
try {
await QueryInstallPip(factory, site, SR.GetString(SR.InstallPip), elevate, output);
} catch (OperationCanceledException) {
return false;
}
} else {
await InstallPip(provider, factory, elevate, output);
}
}
if (output != null) {
output.WriteLine(SR.GetString(SR.PackageInstalling, package));
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) {
output.ShowAndActivate();
} else {
output.Show();
}
}
using (var proc = Run(factory, output, elevate, "install", GetInsecureArg(factory, output), package)) {
var exitCode = await proc;
if (output != null) {
if (exitCode == 0) {
output.WriteLine(SR.GetString(SR.PackageInstallSucceeded, package));
} else {
output.WriteLine(SR.GetString(SR.PackageInstallFailedExitCode, package, exitCode));
}
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) {
output.ShowAndActivate();
} else {
output.Show();
}
}
return exitCode == 0;
}
}
public static async Task<bool> Install(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string package,
bool elevate,
Redirector output = null
) {
factory.ThrowIfNotRunnable("factory");
if (!(await factory.FindModulesAsync("pip")).Any()) {
await InstallPip(provider, factory, elevate, output);
}
using (var proc = Run(factory, output, elevate, "install", GetInsecureArg(factory, output), package)) {
await proc;
return proc.ExitCode == 0;
}
}
/// <summary>
/// Creates a virtual environment. If virtualenv or pip are not
/// installed then they are downloaded and installed automatically.
/// </summary>
public static async Task CreateAndInstallDependencies(
IServiceProvider provider,
IPythonInterpreterFactory factory,
string path
) {
factory.ThrowIfNotRunnable("factory");
var cancel = CancellationToken.None;
var ui = new VsPackageManagerUI(provider);
var pm = factory.PackageManager;
if (pm == null) {
throw new InvalidOperationException(Strings.PackageManagementNotSupported);
}
if (!pm.IsReady) {
await pm.PrepareAsync(ui, cancel);
if (!pm.IsReady) {
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
var modules = await factory.FindModulesAsync("virtualenv", "venv");
bool hasVirtualEnv = modules.Contains("virtualenv") || modules.Contains("venv");
if (!hasVirtualEnv) {
if (!await Install(provider, factory)) {
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
await ContinueCreate(provider, factory, path, false, PackageManagerUIRedirector.Get(pm, ui));
}
