private IPackageManager TryCreatePackageManager(IPythonInterpreterFactory factory)
{
if (factory == null)
{
return(null);
}
var prefixPath = factory.Configuration.GetPrefixPath();
if (string.IsNullOrEmpty(prefixPath) ||
!Directory.Exists(Path.Combine(prefixPath, "conda-meta")))
{
return(null);
}
var condaPath = CondaUtils.GetCondaExecutablePath(prefixPath);
if (string.IsNullOrEmpty(condaPath))
{
// conda.bat is no longer present in a conda 4.4 environment,
// so find a global conda.exe to use.
condaPath = _latestCondaExe.Value;
}
if (string.IsNullOrEmpty(condaPath))
{
return(null);
}
try {
return(new CondaPackageManager(factory, condaPath));
} catch (NotSupportedException) {
return(null);
}
}
private async Task <KeyValuePair <string, string>[]> GetEnvironmentVariables()
{
var prefixPath = _factory.Configuration.GetPrefixPath();
if (_condaLocatorProvider != null && Directory.Exists(prefixPath) && CondaUtils.IsCondaEnvironment(prefixPath))
{
var rootConda = _condaLocatorProvider.FindLocator()?.CondaExecutablePath;
if (File.Exists(rootConda))
{
var env = await CondaUtils.GetActivationEnvironmentVariablesForPrefixAsync(rootConda, prefixPath);
return(env.Union(UnbufferedEnv).ToArray());
}
else
{
// Normally, the root is required for this environment to have been discovered,
// but it could be that the user added this as a custom environment and then
// uninstalled the root. When that's the case, there is no way to activate,
// so proceed without activation env variables.
return(UnbufferedEnv);
}
}
else
{
// Not a conda environment, no activation necessary.
return(UnbufferedEnv);
}
}
public IEnumerable <IPackageManager> GetPackageManagers(IPythonInterpreterFactory factory)
{
if (ExperimentalOptions.UseCondaPackageManager)
{
if (!Directory.Exists(Path.Combine(factory.Configuration.PrefixPath, "conda-meta")))
{
yield break;
}
var condaPath = CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath);
if (string.IsNullOrEmpty(condaPath))
{
// conda.bat is no longer present in a conda 4.4 environment,
// so find a global conda.exe to use.
condaPath = _latestCondaExe.Value;
}
if (string.IsNullOrEmpty(condaPath))
{
yield break;
}
IPackageManager pm = null;
try {
pm = new CondaPackageManager(factory, condaPath);
} catch (NotSupportedException) {
pm = null;
}
if (pm != null)
{
yield return(pm);
}
}
}
private void EnsureActivated()
{
if (_activatedEnvironmentVariables == null)
{
var prefixPath = _factory.Configuration.GetPrefixPath();
if (_condaLocatorProvider != null && Directory.Exists(prefixPath) && CondaUtils.IsCondaEnvironment(prefixPath))
{
var rootConda = _condaLocatorProvider.FindLocator()?.CondaExecutablePath;
if (File.Exists(rootConda))
{
var env = CondaUtils.CaptureActivationEnvironmentVariablesForPrefix(rootConda, prefixPath);
_activatedEnvironmentVariables = env.Union(UnbufferedEnv).ToArray();
}
else
{
// Normally, the root is required for this environment to have been discovered,
// but it could be that the user added this as a custom environment and then
// uninstalled the root. When that's the case, there is no way to activate,
// so proceed without activation env variables.
_activatedEnvironmentVariables = UnbufferedEnv;
}
}
else
{
// Not a conda environment, no activation necessary.
_activatedEnvironmentVariables = UnbufferedEnv;
}
}
}
public static Dictionary <string, string> GetFullEnvironment(LaunchConfiguration config, IServiceProvider serviceProvider)
{
if (config.Interpreter == null)
{
throw new ArgumentNullException(nameof(Interpreter));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
// Start with global environment, add configured environment,
// then add search paths.
var baseEnv = System.Environment.GetEnvironmentVariables();
// Clear search paths from the global environment. The launch
// configuration should include the existing value
var pathVar = config.Interpreter?.PathEnvironmentVariable;
if (string.IsNullOrEmpty(pathVar))
{
pathVar = "PYTHONPATH";
}
baseEnv[pathVar] = string.Empty;
if (CondaUtils.IsCondaEnvironment(config.Interpreter.GetPrefixPath()))
{
var condaExe = CondaUtils.GetRootCondaExecutablePath(serviceProvider);
var prefixPath = config.Interpreter.GetPrefixPath();
if (File.Exists(condaExe) && Directory.Exists(prefixPath))
{
var condaEnv = ThreadHelper.JoinableTaskFactory.Run(() => CondaUtils.GetActivationEnvironmentVariablesForPrefixAsync(condaExe, prefixPath));
baseEnv = PathUtils.MergeEnvironments(baseEnv.AsEnumerable <string, string>(), condaEnv, "Path", pathVar);
}
}
var env = PathUtils.MergeEnvironments(
baseEnv.AsEnumerable <string, string>(),
config.GetEnvironmentVariables(),
"Path", pathVar
);
if (config.SearchPaths != null && config.SearchPaths.Any())
{
env = PathUtils.MergeEnvironments(
env,
new[] {
new KeyValuePair <string, string>(
pathVar,
PathUtils.JoinPathList(config.SearchPaths)
)
},
pathVar
);
}
return(env);
}
private async Task EnsureActivatedAsync()
{
if (_activatedEnvironmentVariables == null)
{
var env = await CondaUtils.CaptureActivationEnvironmentVariablesForRootAsync(_condaPath);
_activatedEnvironmentVariables = env.Union(UnbufferedEnv).ToArray();
}
}
internal static string GetLatestCondaExecutablePath(IEnumerable <IPythonInterpreterFactory> factories)
{
var condaPaths = factories
.Select(factory => CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath, allowBatch: false))
.Where(path => !string.IsNullOrEmpty(path))
.OrderByDescending(path => GetCondaVersion(path));
return(condaPaths.FirstOrDefault());
}
private void FindCondaEnvironments(List <PythonInterpreterInformation> envs)
{
var mainCondaExePath = CondaUtils.GetRootCondaExecutablePath(_site);
if (mainCondaExePath != null)
{
envs.AddRange(FindCondaEnvironments(mainCondaExePath));
}
}
private void DiscoverInterpreterFactories()
{
if (Volatile.Read(ref _ignoreNotifications) > 0)
{
return;
}
DiscoveryStarted?.Invoke(this, EventArgs.Empty);
// Discover the available interpreters...
bool anyChanged = false;
List <PythonInterpreterInformation> found = null;
try {
// Try to find an existing root conda installation
// If the future we may decide to install a private installation of conda/miniconda
var globalFactories = _globalProvider.GetInterpreterFactories().ToList();
var mainCondaExePath = CondaUtils.GetLatestCondaExecutablePath(globalFactories);
if (mainCondaExePath != null)
{
found = FindCondaEnvironments(mainCondaExePath).ToList();
}
} catch (ObjectDisposedException) {
// We are aborting, so silently return with no results.
return;
}
var uniqueIds = new HashSet <string>(found.Select(i => i.Configuration.Id));
// Then update our cached state with the lock held.
lock (_factories) {
foreach (var info in found.MaybeEnumerate())
{
PythonInterpreterInformation existingInfo;
if (!_factories.TryGetValue(info.Configuration.Id, out existingInfo) ||
info.Configuration != existingInfo.Configuration)
{
_factories[info.Configuration.Id] = info;
anyChanged = true;
}
}
// Remove any factories we had before and no longer see...
foreach (var unregistered in _factories.Keys.Except(uniqueIds).ToArray())
{
_factories.Remove(unregistered);
anyChanged = true;
}
}
if (anyChanged)
{
OnInterpreterFactoriesChanged();
}
}
public CPythonCondaPackageManagerProvider(
[Import(typeof(SVsServiceProvider), AllowDefault = true)] IServiceProvider site = null
)
{
_site = site;
// This can be slow, if there are 2 or more global conda installations
// (some conda versions have long startup time), so we only fetch it once.
_latestCondaExe = new Lazy <string>(() => CondaUtils.GetRootCondaExecutablePath(_site));
}
public CPythonCondaPackageManagerProvider(
[Import] CPythonInterpreterFactoryProvider globalProvider
)
{
_globalProvider = globalProvider;
// This can be slow, if there are 2 or more global conda installations
// (some conda versions have long startup time), so we only fetch it once.
_latestCondaExe = new Lazy <string>(() => CondaUtils.GetLatestCondaExecutablePath(_globalProvider.GetInterpreterFactories()));
}
private IPackageManager CreatePackageManager()
{
if (ExperimentalOptions.UseCondaPackageManager && !string.IsNullOrEmpty(CondaUtils.GetCondaExecutablePath(Configuration.PrefixPath)))
{
return(new CondaPackageManager());
}
else
{
return(new PipPackageManager());
}
}
public CondaPackageManager(
IPythonInterpreterFactory factory,
string condaPath
)
{
_factory = factory;
_installedPackages = new List <PackageSpec>();
_availablePackages = new List <PackageSpec>();
_condaPath = condaPath ?? CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath);
_historyPath = Path.Combine(_factory.Configuration.PrefixPath, "conda-meta", "history");
}
public static CondaEnvironmentManager Create(IServiceProvider serviceProvider)
{
var condaPath = CondaUtils.GetRootCondaExecutablePath(serviceProvider);
if (!string.IsNullOrEmpty(condaPath))
{
return(new CondaEnvironmentManager(condaPath));
}
return(null);
}
private void FindCondaEnvironments(List <PythonInterpreterInformation> envs)
{
// Try to find an existing root conda installation
// If the future we may decide to install a private installation of conda/miniconda
var globalFactories = _globalProvider.GetInterpreterFactories().ToList();
var mainCondaExePath = CondaUtils.GetLatestCondaExecutablePath(globalFactories);
if (mainCondaExePath != null)
{
envs.AddRange(FindCondaEnvironments(mainCondaExePath));
}
}
private static string GetLatestCondaExecutablePath(IServiceProvider serviceProvider, IEnumerable <IPythonInterpreterFactory> factories)
{
var condaPaths = factories
.Select(factory => new {
PrefixPath = factory.Configuration.PrefixPath,
ExePath = CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath, allowBatch: false)
})
.Where(obj => !string.IsNullOrEmpty(obj.ExePath))
.OrderByDescending(obj => GetCondaVersion(obj.PrefixPath, obj.ExePath));
return(condaPaths.FirstOrDefault()?.ExePath);
}
private IPythonInterpreterFactory CreateFactory(PythonInterpreterInformation info)
{
return(InterpreterFactoryCreator.CreateInterpreterFactory(
info.Configuration,
new InterpreterFactoryCreationOptions {
PackageManager = CondaUtils.HasConda(info.Configuration.PrefixPath) ? BuiltInPackageManagers.Conda : BuiltInPackageManagers.Pip,
WatchFileSystem = true,
NoDatabase = ExperimentalOptions.NoDatabaseFactory,
DatabasePath = ExperimentalOptions.NoDatabaseFactory ?
DatabasePathSelector.CalculateVSLocalDatabasePath(_site, info.Configuration, 1) :
DatabasePathSelector.CalculateGlobalDatabasePath(info.Configuration, PythonTypeDatabase.FormatVersion)
}
));
}
public CondaPackageManager(
IPythonInterpreterFactory factory,
string condaPath
)
{
_factory = factory;
_installedPackages = new List <PackageSpec>();
_availablePackages = new List <PackageSpec>();
_condaPath = condaPath ?? CondaUtils.GetCondaExecutablePath(factory.Configuration.GetPrefixPath());
if (!File.Exists(_condaPath))
{
throw new NotSupportedException();
}
_historyPath = Path.Combine(_factory.Configuration.GetPrefixPath(), "conda-meta", "history");
}
public static CondaEnvironmentManager Create(IInterpreterRegistryService registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var condaPath = CondaUtils.GetLatestCondaExecutablePath(registry.Interpreters);
if (!string.IsNullOrEmpty(condaPath))
{
return(new CondaEnvironmentManager(condaPath));
}
return(null);
}
public IEnumerable <IPackageManager> GetPackageManagers(IPythonInterpreterFactory factory)
{
IPackageManager pm = null;
string condaPath;
if (ExperimentalOptions.UseCondaPackageManager &&
!string.IsNullOrEmpty(condaPath = CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath)))
{
try {
pm = new CondaPackageManager(factory, condaPath);
} catch (NotSupportedException) {
pm = null;
}
if (pm != null)
{
yield return(pm);
}
}
}
private string GetMainCondaExecutablePath()
{
// Try to find an existing root conda installation
// If the future we may decide to install a private installation of conda/miniconda
string mainCondaExePath = null;
var globalFactories = _globalProvider.GetInterpreterFactories().ToList();
foreach (var factory in globalFactories)
{
var condaPath = CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath, allowBatch: false);
if (!string.IsNullOrEmpty(condaPath))
{
// TODO: need to pick the newest conda.exe on the machine,
// not just the first one found.
// Unfortunately, conda.exe doesn't have a version resource,
// we'll need to figure some other way to determine conda version.
mainCondaExePath = condaPath;
break;
}
}
return(mainCondaExePath);
}
public void SetInterpreterFactory(IPythonInterpreterFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (!File.Exists(factory.Configuration?.InterpreterPath))
{
throw new NotSupportedException();
}
_factory = factory;
_condaPath = CondaUtils.GetCondaExecutablePath(factory.Configuration.PrefixPath);
_historyPath = Path.Combine(_factory.Configuration.PrefixPath, "conda-meta", "history");
if (_historyWatcher != null)
{
// Watch the conda-meta/history file, which is updated after
// a package is installed or uninstalled successfully.
// Note: conda packages don't all install under lib/site-packages.
try {
_historyWatcher.Path = Path.GetDirectoryName(_historyPath);
_historyWatcher.EnableRaisingEvents = true;
} catch (ArgumentException) {
} catch (IOException) {
}
}
Task.Delay(100).ContinueWith(async t => {
try {
await UpdateIsReadyAsync(false, CancellationToken.None);
} catch (Exception ex) when(!ex.IsCriticalException())
{
Debug.Fail(ex.ToUnhandledExceptionMessage(GetType()));
}
}).DoNotWait();
}
internal async static Task <CondaInfoResult> ExecuteCondaInfoAsync(string condaPath)
{
var activationVars = await CondaUtils.GetActivationEnvironmentVariablesForRootAsync(condaPath);
var envVars = activationVars.Union(UnbufferedEnv).ToArray();
var args = new[] { "info", "--json" };
using (var output = ProcessOutput.Run(condaPath, args, null, envVars, false, null)) {
output.Wait();
if (output.ExitCode == 0)
{
var json = string.Join(Environment.NewLine, output.StandardOutputLines);
try {
return(JsonConvert.DeserializeObject <CondaInfoResult>(json));
} catch (JsonException ex) {
Debug.WriteLine("Failed to parse: {0}".FormatInvariant(ex.Message));
Debug.WriteLine(json);
return(null);
}
}
return(null);
}
}
private async Task <KeyValuePair <string, string>[]> GetEnvironmentVariables()
{
var activationVars = await CondaUtils.GetActivationEnvironmentVariablesForRootAsync(_condaPath);
return(activationVars.Union(UnbufferedEnv).ToArray());
}
public static Dictionary <string, string> GetFullEnvironment(LaunchConfiguration config, IServiceProvider serviceProvider)
{
if (config.Interpreter == null)
{
throw new ArgumentNullException(nameof(Interpreter));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
// Start with global environment, add configured environment,
// then add search paths.
var baseEnv = System.Environment.GetEnvironmentVariables();
// Clear search paths from the global environment. The launch
// configuration should include the existing value
var pathVar = config.Interpreter?.PathEnvironmentVariable;
if (string.IsNullOrEmpty(pathVar))
{
pathVar = "PYTHONPATH";
}
baseEnv[pathVar] = string.Empty;
// TODO: We could introduce a cache so that we don't activate the
// environment + capture the env variables every time. Not doing this
// right now to minimize risk/complexity so close to release.
if (CondaUtils.IsCondaEnvironment(config.Interpreter.GetPrefixPath()))
{
var condaExe = CondaUtils.GetRootCondaExecutablePath(serviceProvider);
var prefixPath = config.Interpreter.GetPrefixPath();
if (File.Exists(condaExe) && Directory.Exists(prefixPath))
{
var condaEnv = CondaUtils.CaptureActivationEnvironmentVariablesForPrefix(condaExe, prefixPath);
baseEnv = PathUtils.MergeEnvironments(baseEnv.AsEnumerable <string, string>(), condaEnv, "Path", pathVar);
}
}
var env = PathUtils.MergeEnvironments(
baseEnv.AsEnumerable <string, string>(),
config.GetEnvironmentVariables(),
"Path", pathVar
);
if (config.SearchPaths != null && config.SearchPaths.Any())
{
env = PathUtils.MergeEnvironments(
env,
new[] {
new KeyValuePair <string, string>(
pathVar,
PathUtils.JoinPathList(config.SearchPaths)
)
},
pathVar
);
}
return(env);
}
