private bool IsRealInterpreter(IPythonInterpreterFactory factory) {
if (factory == null) {
return false;
}
var interpreterService = _serviceProvider.GetComponentModel().GetService<IInterpreterOptionsService>();
return interpreterService != null && interpreterService.NoInterpretersValue != factory;
}
internal static IVsInteractiveWindow/*!*/ EnsureReplWindow(IServiceProvider serviceProvider, IPythonInterpreterFactory factory, PythonProjectNode project) {
var compModel = serviceProvider.GetComponentModel();
var provider = compModel.GetService<InteractiveWindowProvider>();
string replId = PythonReplEvaluatorProvider.GetReplId(factory, project);
var window = provider.FindReplWindow(replId);
if (window == null) {
window = provider.CreateInteractiveWindow(
serviceProvider.GetPythonContentType(),
factory.Description + " Interactive",
typeof(PythonLanguageInfo).GUID,
replId
);
var toolWindow = window as ToolWindowPane;
if (toolWindow != null) {
toolWindow.BitmapImageMoniker = KnownMonikers.PYInteractiveWindow;
}
var pyService = serviceProvider.GetPythonToolsService();
window.InteractiveWindow.SetSmartUpDown(pyService.GetInteractiveOptions(factory).ReplSmartHistory);
}
if (project != null && project.Interpreters.IsProjectSpecific(factory)) {
project.AddActionOnClose(window, BasePythonReplEvaluator.CloseReplWindow);
}
return window;
}
public void AddFactory(IPythonInterpreterFactory factory) {
_factories.Add(factory);
var evt = InterpreterFactoriesChanged;
if (evt != null) {
evt(this, EventArgs.Empty);
}
}
private static ProcessOutput Run(
IPythonInterpreterFactory factory,
Redirector output,
bool elevate,
params string[] cmd
) {
factory.ThrowIfNotRunnable("factory");
IEnumerable<string> args;
if (factory.Configuration.Version >= SupportsDashMPip) {
args = new[] { "-m", "pip" }.Concat(cmd);
} else {
// Manually quote the code, since we are passing false to
// quoteArgs below.
args = new[] { "-c", "\"import pip; pip.main()\"" }.Concat(cmd);
}
return ProcessOutput.Run(
factory.Configuration.InterpreterPath,
args,
factory.Configuration.PrefixPath,
UnbufferedEnv,
false,
output,
quoteArgs: false,
elevate: elevate
);
}
public AddVirtualEnvironmentView(
PythonProjectNode project,
IInterpreterRegistryService interpreterService,
IPythonInterpreterFactory selectInterpreter
) {
_interpreterService = interpreterService;
_project = project;
VirtualEnvBasePath = _projectHome = project.ProjectHome;
Interpreters = new ObservableCollection<InterpreterView>(InterpreterView.GetInterpreters(project.Site, project));
var selection = Interpreters.FirstOrDefault(v => v.Interpreter == selectInterpreter);
if (selection == null) {
selection = Interpreters.FirstOrDefault(v => v.Interpreter == project.GetInterpreterFactory())
?? Interpreters.LastOrDefault();
}
BaseInterpreter = selection;
_project.InterpreterFactoriesChanged += OnInterpretersChanged;
var venvName = "env";
for (int i = 1; Directory.Exists(Path.Combine(_projectHome, venvName)); ++i) {
venvName = "env" + i.ToString();
}
VirtualEnvName = venvName;
CanInstallRequirementsTxt = File.Exists(PathUtils.GetAbsoluteFilePath(_projectHome, "requirements.txt"));
WillInstallRequirementsTxt = CanInstallRequirementsTxt;
}
public void Save(IPythonInterpreterFactory interpreter) {
base.Save();
_pyService.SaveString(_id + InterpreterOptionsSetting, _category, InterpreterOptions ?? "");
_pyService.SaveBool(_id + EnableAttachSetting, _category, EnableAttach);
_pyService.SaveString(_id + ExecutionModeSetting, _category, ExecutionMode ?? "");
_pyService.SaveString(_id + StartupScriptSetting, _category, StartupScript ?? "");
var replProvider = _serviceProvider.GetComponentModel().GetService<IReplWindowProvider>();
if (replProvider != null) {
// propagate changed settings to existing REPL windows
foreach (var replWindow in replProvider.GetReplWindows()) {
PythonReplEvaluator pyEval = replWindow.Evaluator as PythonReplEvaluator;
if (EvaluatorUsesThisInterpreter(pyEval, interpreter)) {
if (UseInterpreterPrompts) {
replWindow.UseInterpreterPrompts();
} else {
replWindow.SetPrompts(PrimaryPrompt, SecondaryPrompt);
}
#if !DEV14_OR_LATER
replWindow.SetOptionValue(ReplOptions.DisplayPromptInMargin, !InlinePrompts);
#endif
replWindow.SetSmartUpDown(ReplSmartHistory);
}
}
}
}
public static async Task<HashSet<string>> List(IPythonInterpreterFactory factory) {
using (var proc = Run(factory, null, false, "list")) {
if (await proc == 0) {
return new HashSet<string>(proc.StandardOutputLines
.Select(line => Regex.Match(line, "(?<name>.+?) \\((?<version>.+?)\\)"))
.Where(match => match.Success)
.Select(match => string.Format("{0}=={1}",
match.Groups["name"].Value,
match.Groups["version"].Value
))
);
}
}
// Pip failed, so return a directory listing
var packagesPath = Path.Combine(factory.Configuration.LibraryPath, "site-packages");
HashSet<string> result = null;
if (Directory.Exists(packagesPath)) {
result = await Task.Run(() => new HashSet<string>(Directory.EnumerateDirectories(packagesPath)
.Select(path => Path.GetFileName(path))
.Select(name => PackageNameRegex.Match(name))
.Where(match => match.Success)
.Select(match => match.Groups["name"].Value)
))
.SilenceException<IOException, HashSet<string>>()
.SilenceException<UnauthorizedAccessException, HashSet<string>>()
.HandleAllExceptions(SR.ProductName, typeof(Pip));
}
return result ?? new HashSet<string>();
}
private static async Task<int> ContinueRun(
IPythonInterpreterFactory factory,
Redirector output,
bool elevate,
params string[] cmd
) {
bool isScript;
var easyInstallPath = GetEasyInstallPath(factory, out isScript);
if (easyInstallPath == null) {
throw new FileNotFoundException("Cannot find setuptools ('easy_install.exe')");
}
var args = cmd.ToList();
args.Insert(0, "--always-copy");
args.Insert(0, "--always-unzip");
if (isScript) {
args.Insert(0, ProcessOutput.QuoteSingleArgument(easyInstallPath));
easyInstallPath = factory.Configuration.InterpreterPath;
}
using (var proc = ProcessOutput.Run(
easyInstallPath,
args,
factory.Configuration.PrefixPath,
UnbufferedEnv,
false,
output,
false,
elevate
)) {
return await proc;
}
}
public IronPythonAnalysis(
IPythonInterpreterFactory factory,
IPythonInterpreter interpreter = null,
string builtinName = null
) : base(factory, interpreter, builtinName) {
((IronPythonInterpreter)Analyzer.Interpreter).Remote.AddAssembly(new ObjectHandle(typeof(IronPythonAnalysisTest).Assembly));
}
public PythonReplEvaluator(IPythonInterpreterFactory interpreter, IServiceProvider serviceProvider, PythonReplEvaluatorOptions options, IInterpreterOptionsService interpreterService = null)
: base(serviceProvider, serviceProvider.GetPythonToolsService(), options) {
_interpreter = interpreter;
_interpreterService = interpreterService;
if (_interpreterService != null) {
_interpreterService.InterpretersChanged += InterpretersChanged;
}
}
public void SetDefault(IPythonInterpreterFactory factory) {
Assert.IsNotNull(factory, "Cannot set default to null");
var interpreterService = _model.GetService<IInterpreterOptionsService>();
Assert.IsNotNull(interpreterService);
CurrentDefault = factory;
interpreterService.DefaultInterpreter = factory;
}
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;
}
/// <summary>
/// Determines whether two interpreter factories are equivalent.
/// </summary>
public static bool IsEqual(this IPythonInterpreterFactory x, IPythonInterpreterFactory y) {
if (x == null || y == null) {
return x == null && y == null;
}
if (x.GetType() != y.GetType()) {
return false;
}
return x.Configuration.Equals(y.Configuration);
}
public DefaultInterpreterSetter(IPythonInterpreterFactory factory) {
var props = VsIdeTestHostContext.Dte.get_Properties("Python Tools", "Interpreters");
Assert.IsNotNull(props);
OriginalInterpreter = props.Item("DefaultInterpreter").Value;
OriginalVersion = props.Item("DefaultInterpreterVersion").Value;
props.Item("DefaultInterpreter").Value = factory.Id;
props.Item("DefaultInterpreterVersion").Value = string.Format("{0}.{1}", factory.Configuration.Version.Major, factory.Configuration.Version.Minor);
}
public bool RemoveFactory(IPythonInterpreterFactory factory) {
if (_factories.Remove(factory)) {
var evt = InterpreterFactoriesChanged;
if (evt != null) {
evt(this, EventArgs.Empty);
}
return true;
}
return false;
}
public DefaultInterpreterSetter(IPythonInterpreterFactory factory, IServiceProvider site = null) {
Assert.IsNotNull(factory, "Cannot set default to null");
_model = (IComponentModel)(site ?? VSTestContext.ServiceProvider).GetService(typeof(SComponentModel));
var interpreterService = _model.GetService<IInterpreterOptionsService>();
Assert.IsNotNull(interpreterService);
OriginalInterpreter = interpreterService.DefaultInterpreter;
CurrentDefault = factory;
interpreterService.DefaultInterpreter = factory;
}
internal EnvironmentView(
IInterpreterOptionsService service,
IInterpreterRegistryService registry,
IPythonInterpreterFactory factory,
Redirector redirector
) {
if (service == null) {
throw new ArgumentNullException(nameof(service));
}
if (registry == null) {
throw new ArgumentNullException(nameof(registry));
}
if (factory == null) {
throw new ArgumentNullException(nameof(factory));
}
if (factory.Configuration == null) {
throw new ArgumentException("factory must include a configuration");
}
_service = service;
_registry = registry;
Factory = factory;
Configuration = Factory.Configuration;
_withDb = factory as IPythonInterpreterFactoryWithDatabase;
if (_withDb != null) {
_withDb.IsCurrentChanged += Factory_IsCurrentChanged;
IsCheckingDatabase = _withDb.IsCheckingDatabase;
IsCurrent = _withDb.IsCurrent;
}
if (_service.IsConfigurable(Factory.Configuration.Id)) {
IsConfigurable = true;
}
Description = Factory.Configuration.Description;
IsDefault = (_service != null && _service.DefaultInterpreterId == Configuration.Id);
PrefixPath = Factory.Configuration.PrefixPath;
InterpreterPath = Factory.Configuration.InterpreterPath;
WindowsInterpreterPath = Factory.Configuration.WindowsInterpreterPath;
Extensions = new ObservableCollection<object>();
Extensions.Add(new EnvironmentPathsExtensionProvider());
if (IsConfigurable) {
Extensions.Add(new ConfigurationExtensionProvider(_service, alwaysCreateNew: false));
}
CanBeDefault = Factory.CanBeDefault();
Company = _registry.GetProperty(Factory.Configuration.Id, CompanyKey) as string ?? "";
SupportUrl = _registry.GetProperty(Factory.Configuration.Id, SupportUrlKey) as string ?? "";
}
/// <summary>
/// Creates a provider for managing packages through pip.
/// </summary>
/// <param name="factory">The associated interpreter.</param>
/// <param name="index">
/// The index URL. Defaults to https://pypi.python.org/pypi/
/// </param>
/// <param name="indexName">
/// Display name of the index. Defaults to PyPI.
/// </param>
public PipExtensionProvider(
IPythonInterpreterFactory factory,
string index = null,
string indexName = null
) {
_factory = factory;
_output = new PipRedirector(this);
if (!string.IsNullOrEmpty(index) && Uri.TryCreate(index, UriKind.Absolute, out _index)) {
_indexName = string.IsNullOrEmpty(indexName) ? _index.Host : indexName;
}
_cache = PipPackageCache.GetCache(_index, _indexName);
}
public static InstallPythonPackageView ShowDialog(
IServiceProvider serviceProvider,
IPythonInterpreterFactory factory,
IInterpreterOptionsService service
) {
var wnd = new InstallPythonPackage(serviceProvider, factory, service);
if (wnd.ShowModal() ?? false) {
return wnd._view;
} else {
return null;
}
}
/// <summary>
/// Installs virtualenv. If pip is not installed, the returned task will
/// succeed but error text will be passed to the redirector.
/// </summary>
public static Task<bool> Install(IServiceProvider provider, IPythonInterpreterFactory factory, Redirector output = null) {
bool elevate = provider.GetPythonToolsService().GeneralOptions.ElevatePip;
if (factory.Configuration.Version < new Version(2, 5)) {
if (output != null) {
output.WriteErrorLine("Python versions earlier than 2.5 are not supported by PTVS.");
}
throw new OperationCanceledException();
} else if (factory.Configuration.Version == new Version(2, 5)) {
return Pip.Install(provider, factory, "https://go.microsoft.com/fwlink/?LinkID=317970", elevate, output);
} else {
return Pip.Install(provider, factory, "https://go.microsoft.com/fwlink/?LinkID=317969", elevate, output);
}
}
public PythonAnalysis CreateAnalyzer(IPythonInterpreterFactory factory = null, bool allowParseErrors = false) {
var analysis = CreateAnalyzerInternal(factory ?? DefaultFactoryV2);
analysis.AssertOnParseErrors = !allowParseErrors;
analysis.ModuleContext = DefaultContext;
analysis.SetLimits(GetLimits());
if (_toDispose == null) {
_toDispose = new List<IDisposable>();
}
_toDispose.Add(analysis);
return analysis;
}
private static string GetEasyInstallPath(IPythonInterpreterFactory factory, out bool isScript) {
factory.ThrowIfNotRunnable("factory");
foreach (var path in EasyInstallLocations) {
string easyInstallPath = Path.Combine(factory.Configuration.PrefixPath, path.Key);
isScript = path.Value;
if (File.Exists(easyInstallPath)) {
return easyInstallPath;
}
}
isScript = false;
return null;
}
/// <summary>
/// Installs virtualenv. If pip is not installed, the returned task will
/// succeed but error text will be passed to the redirector.
/// </summary>
public static Task<bool> Install(IServiceProvider provider, IPythonInterpreterFactory factory) {
var ui = new VsPackageManagerUI(provider);
if (factory.Configuration.Version < new Version(2, 5)) {
ui.OnErrorTextReceived(null, "Python versions earlier than 2.5 are not supported by PTVS.\n");
throw new OperationCanceledException();
} else if (factory.PackageManager == null) {
ui.OnErrorTextReceived(null, Strings.PackageManagementNotSupported_Package.FormatUI("virtualenv"));
throw new OperationCanceledException();
} else if (factory.Configuration.Version == new Version(2, 5)) {
return factory.PackageManager.InstallAsync(PackageSpec.FromArguments("https://go.microsoft.com/fwlink/?LinkID=317970"), ui, CancellationToken.None);
} else {
return factory.PackageManager.InstallAsync(PackageSpec.FromArguments("https://go.microsoft.com/fwlink/?LinkID=317969"), ui, CancellationToken.None);
}
}
private InstallPythonPackage(
IServiceProvider serviceProvider,
IPythonInterpreterFactory factory,
IInterpreterOptionsService service
) {
_view = new InstallPythonPackageView(
serviceProvider,
!Pip.IsSecureInstall(factory),
Conda.CanInstall(factory, service)
);
DataContext = _view;
InitializeComponent();
_textBox.Focus();
}
internal EnvironmentView(
IInterpreterOptionsService service,
IPythonInterpreterFactory factory,
Redirector redirector
) {
if (service == null) {
throw new ArgumentNullException("service");
}
if (factory == null) {
throw new ArgumentNullException("factory");
}
_service = service;
Factory = factory;
_withDb = factory as IPythonInterpreterFactoryWithDatabase;
if (_withDb != null) {
_withDb.IsCurrentChanged += Factory_IsCurrentChanged;
IsCheckingDatabase = _withDb.IsCheckingDatabase;
IsCurrent = _withDb.IsCurrent;
}
var configurableProvider = _service != null ?
_service.KnownProviders
.OfType<ConfigurablePythonInterpreterFactoryProvider>()
.FirstOrDefault() :
null;
if (configurableProvider != null && configurableProvider.IsConfigurable(factory)) {
IsConfigurable = true;
}
Description = Factory.Description;
IsDefault = (_service != null && _service.DefaultInterpreter == Factory);
PrefixPath = Factory.Configuration.PrefixPath;
InterpreterPath = Factory.Configuration.InterpreterPath;
WindowsInterpreterPath = Factory.Configuration.WindowsInterpreterPath;
LibraryPath = Factory.Configuration.LibraryPath;
Extensions = new ObservableCollection<object>();
Extensions.Add(new EnvironmentPathsExtensionProvider());
if (IsConfigurable) {
Extensions.Add(new ConfigurationExtensionProvider(configurableProvider));
}
CanBeDefault = Factory.CanBeDefault();
}
public TestAnalyzer(
IPythonInterpreterFactory factory,
string containerFilePath,
string codeFileBasePath,
Uri executorUri
) {
_analyzer = PythonAnalyzer.CreateAsync(factory).WaitAndUnwrapExceptions();
_analyzer.Limits = AnalysisLimits.GetStandardLibraryLimits();
_analyzer.Limits.ProcessCustomDecorators = false;
_containerFilePath = containerFilePath;
_codeFileBasePath = codeFileBasePath;
_executorUri = executorUri;
_entries = new List<IPythonProjectEntry>();
}
/// <summary>
/// Creates a provider for managing packages through pip.
/// </summary>
/// <param name="factory">The associated interpreter.</param>
/// <param name="index">
/// The index URL. Defaults to https://pypi.python.org/pypi/
/// </param>
/// <param name="indexName">
/// Display name of the index. Defaults to PyPI.
/// </param>
public PipExtensionProvider(
IPythonInterpreterFactory factory,
string index = null,
string indexName = null
) {
_factory = factory;
_packageManager = _factory.PackageManager;
if (_packageManager == null) {
throw new NotSupportedException();
}
if (!string.IsNullOrEmpty(index) && Uri.TryCreate(index, UriKind.Absolute, out _index)) {
_indexName = string.IsNullOrEmpty(indexName) ? _index.Host : indexName;
}
_cache = PipPackageCache.GetCache(_index, _indexName);
}
public IPythonInterpreterFactory EnsureFactory() {
if (Factory == null) {
lock (this) {
if (Factory == null) {
Factory = InterpreterFactoryCreator.CreateInterpreterFactory(
Configuration,
new InterpreterFactoryCreationOptions {
PackageManager = new PipPackageManager(),
WatchFileSystem = true
}
);
}
}
}
return Factory;
}
public BaseAnalysisTest(IPythonInterpreterFactory factory, IPythonInterpreter interpreter) {
InterpreterFactory = factory;
Interpreter = interpreter;
var objectType = Interpreter.GetBuiltinType(BuiltinTypeId.Object);
Assert.IsNotNull(objectType);
var intType = Interpreter.GetBuiltinType(BuiltinTypeId.Int);
var bytesType = Interpreter.GetBuiltinType(BuiltinTypeId.Bytes);
var listType = Interpreter.GetBuiltinType(BuiltinTypeId.List);
var functionType = Interpreter.GetBuiltinType(BuiltinTypeId.Function);
_objectMembers = objectType.GetMemberNames(DefaultContext).ToArray();
_strMembers = bytesType.GetMemberNames(DefaultContext).ToArray();
_listMembers = listType.GetMemberNames(DefaultContext).ToArray();
_intMembers = intType.GetMemberNames(DefaultContext).ToArray();
_functionMembers = functionType.GetMemberNames(DefaultContext).ToArray();
}
public void Load() {
var configurable = _pyService._interpreterOptionsService.KnownProviders.OfType<ConfigurablePythonInterpreterFactoryProvider>().FirstOrDefault();
Debug.Assert(configurable != null);
Display = _interpreter.Description;
Id = _interpreter.Id;
InterpreterPath = _interpreter.Configuration.InterpreterPath;
WindowsInterpreterPath = _interpreter.Configuration.WindowsInterpreterPath;
LibraryPath = _interpreter.Configuration.LibraryPath;
Version = _interpreter.Configuration.Version.ToString();
Architecture = FormatArchitecture(_interpreter.Configuration.Architecture);
PathEnvironmentVariable = _interpreter.Configuration.PathEnvironmentVariable;
IsConfigurable = configurable != null && configurable.IsConfigurable(_interpreter);
SupportsCompletionDb = _interpreter is IPythonInterpreterFactoryWithDatabase;
Factory = _interpreter;
}
/// <summary>
/// Returns true if installing a package will be secure.
///
/// This returns false for Python 2.5 and earlier because it does not
/// include the required SSL support by default. No detection is done to
/// determine whether the support has been added separately.
/// </summary>
public static bool IsSecureInstall(IPythonInterpreterFactory factory)
{
return(factory.Configuration.Version > new Version(2, 5));
}
public AnalysisView(
string dbDir,
Version version = null,
bool withContention = false,
bool withRecursion = false
)
{
var paths = new List <string>();
paths.Add(dbDir);
while (!File.Exists(IOPath.Combine(paths[0], "__builtin__.idb")) &&
!File.Exists(IOPath.Combine(paths[0], "builtins.idb")))
{
var upOne = IOPath.GetDirectoryName(paths[0]);
if (string.IsNullOrEmpty(upOne) || upOne == paths[0])
{
break;
}
paths.Insert(0, upOne);
}
if (withRecursion)
{
paths.AddRange(Directory.EnumerateDirectories(dbDir, "*", SearchOption.AllDirectories));
}
if (version == null)
{
if (File.Exists(IOPath.Combine(paths[0], "builtins.idb")))
{
version = new Version(3, 3);
}
else
{
version = new Version(2, 7);
}
}
_factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(
version,
dbDir,
paths.ToArray()
);
Path = dbDir;
_interpreter = _factory.CreateInterpreter();
_context = _interpreter.CreateModuleContext();
var modNames = _interpreter.GetModuleNames();
IEnumerable <Tuple <string, string> > modItems;
if (!withRecursion)
{
modItems = modNames
.Select(n => Tuple.Create(n, IOPath.Combine(dbDir, n + ".idb")))
.Where(t => File.Exists(t.Item2));
}
else
{
modItems = modNames
.Select(n => Tuple.Create(
n,
Directory.EnumerateFiles(dbDir, n + ".idb", SearchOption.AllDirectories).FirstOrDefault()
))
.Where(t => File.Exists(t.Item2));
}
var stopwatch = new Stopwatch();
stopwatch.Start();
if (withContention)
{
modItems = modItems
.AsParallel()
.WithExecutionMode(ParallelExecutionMode.ForceParallelism);
}
_modules = modItems
.Select(t => new ModuleView(_interpreter, _context, t.Item1, t.Item2))
.OrderBy(m => m.SortKey)
.ThenBy(m => m.Name)
.ToList <IAnalysisItemView>();
stopwatch.Stop();
_modules.Insert(0, new KnownTypesView(_interpreter, version));
LoadMilliseconds = stopwatch.ElapsedMilliseconds;
TopLevelModuleCount = _modules.Count - 1;
}
/// <summary>
/// Removes an interpreter factory from the project. This function will
/// modify the project, but does not handle source control.
/// </summary>
/// <param name="factory">
/// The id of the factory to remove. The function returns silently if
/// the factory is not known by this provider.
/// </param>
public void RemoveInterpreterFactory(IPythonInterpreterFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (!_factories.ContainsKey(factory))
{
return;
}
string rootPath;
if (_rootPaths.TryGetValue(factory.Id, out rootPath))
{
_rootPaths.Remove(factory.Id);
foreach (var item in _project.GetItems(InterpreterItem))
{
Guid itemId;
if (Guid.TryParse(item.GetMetadataValue(IdKey), out itemId) && factory.Id == itemId)
{
_project.RemoveItem(item);
_project.MarkDirty();
break;
}
}
}
else
{
foreach (var item in _project.GetItems(InterpreterReferenceItem))
{
Guid itemId;
Version itemVer;
var match = InterpreterReferencePath.Match(item.EvaluatedInclude);
if (match != null && match.Success && match.Groups.Cast <Group>().All(g => g.Success) &&
Guid.TryParse(match.Groups["id"].Value, out itemId) &&
Version.TryParse(match.Groups["version"].Value, out itemVer) &&
factory.Id == itemId &&
factory.Configuration.Version == itemVer)
{
_project.RemoveItem(item);
_project.MarkDirty();
break;
}
}
}
bool raiseEvent;
FactoryInfo factInfo;
lock (_factoriesLock) {
raiseEvent = _factories.TryGetValue(factory, out factInfo) && _factories.Remove(factory);
}
if (factInfo != null &&
factInfo.Owned &&
factory is IDisposable)
{
((IDisposable)factory).Dispose();
}
UpdateActiveInterpreter();
if (raiseEvent)
{
OnInterpreterFactoriesChanged();
}
}
public bool IsInterpreterLocked(IPythonInterpreterFactory factory, object moniker)
{
throw new NotImplementedException();
}
/// <summary>
/// Returns true if the provided interpreter is available to this
/// project.
/// </summary>
/// <remarks>
/// If the project did not specify any interpreters, the global default
/// interpreter is available, but this function will still return false.
/// </remarks>
public bool Contains(IPythonInterpreterFactory factory)
{
lock (_factoriesLock) {
return(_factories.ContainsKey(factory));
}
}
private async Task ApplyCustomAsync()
{
IPythonInterpreterFactory factory = null;
if (RegisterCustomEnv)
{
Version version;
if (!Version.TryParse(VersionName, out version))
{
version = null;
}
factory = await CustomEnv.CreateCustomEnv(
RegistryService,
OptionsService,
PrefixPath,
InterpreterPath,
WindowsInterpreterPath,
PathEnvironmentVariable,
InterpreterArchitecture.TryParse(ArchitectureName ?? ""),
version,
Description
);
}
else
{
Debug.Assert(SelectedProject != null, "Project is null, UI should not have allowed this");
if (SelectedProject != null)
{
Version version;
if (!Version.TryParse(VersionName, out version))
{
version = null;
}
factory = SelectedProject.Node.AddMSBuildEnvironment(
RegistryService,
PrefixPath,
InterpreterPath,
WindowsInterpreterPath,
PathEnvironmentVariable,
version,
InterpreterArchitecture.TryParse(ArchitectureName ?? ""),
Description
);
}
}
if (factory != null)
{
if (SelectedProject != null)
{
SelectedProject.Node.AddInterpreter(factory.Configuration.Id);
if (SetAsCurrent)
{
SelectedProject.Node.SetInterpreterFactory(factory);
}
}
if (SetAsDefault)
{
OptionsService.DefaultInterpreter = factory;
}
}
}
private static async Task ContinueCreate(IServiceProvider provider, IPythonInterpreterFactory factory, string path, bool useVEnv, Redirector output)
{
path = PathUtils.TrimEndSeparator(path);
var name = Path.GetFileName(path);
var dir = Path.GetDirectoryName(path);
if (output != null)
{
output.WriteLine(Strings.VirtualEnvCreating.FormatUI(path));
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForVirtualEnvCreate)
{
output.ShowAndActivate();
}
else
{
output.Show();
}
}
var workspaceFactoryProvider = provider.GetComponentModel().GetService <WorkspaceInterpreterFactoryProvider>();
using (workspaceFactoryProvider?.SuppressDiscoverFactories(forceDiscoveryOnDispose: true)) {
// Ensure the target directory exists.
Directory.CreateDirectory(dir);
using (var proc = ProcessOutput.Run(
factory.Configuration.InterpreterPath,
new[] { "-m", useVEnv ? "venv" : "virtualenv", name },
dir,
UnbufferedEnv,
false,
output
)) {
var exitCode = await proc;
if (output != null)
{
if (exitCode == 0)
{
output.WriteLine(Strings.VirtualEnvCreationSucceeded.FormatUI(path));
}
else
{
output.WriteLine(Strings.VirtualEnvCreationFailedExitCode.FormatUI(path, exitCode));
}
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForVirtualEnvCreate)
{
output.ShowAndActivate();
}
else
{
output.Show();
}
}
if (exitCode != 0 || !Directory.Exists(path))
{
throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path));
}
}
}
}
/// <summary>
/// Gets the set of search paths for the specified factory as
/// efficiently as possible. This may involve executing the
/// interpreter, and may cache the paths for retrieval later.
/// </summary>
public static async Task <IList <PythonLibraryPath> > GetDatabaseSearchPathsAsync(IPythonInterpreterFactory factory)
{
var dbPath = (factory as PythonInterpreterFactoryWithDatabase)?.DatabasePath;
if (!string.IsNullOrEmpty(dbPath))
{
var paths = GetCachedDatabaseSearchPaths(dbPath);
if (paths != null)
{
return(paths);
}
}
try {
var paths = await GetUncachedDatabaseSearchPathsAsync(factory.Configuration.InterpreterPath);
if (!string.IsNullOrEmpty(dbPath))
{
WriteDatabaseSearchPaths(dbPath, paths);
}
return(paths);
} catch (InvalidOperationException) {
// Failed to get paths
}
var ospy = PathUtils.FindFile(factory.Configuration.PrefixPath, "os.py", firstCheck: new[] { "Lib" });
if (!string.IsNullOrEmpty(ospy))
{
return(GetDefaultDatabaseSearchPaths(PathUtils.GetParent(ospy)));
}
return(Array.Empty <PythonLibraryPath>());
}
internal EnvironmentView(
IInterpreterOptionsService service,
IInterpreterRegistryService registry,
IPythonInterpreterFactory factory,
Redirector redirector
)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (factory.Configuration == null)
{
throw new ArgumentException("factory must include a configuration");
}
_service = service;
_registry = registry;
Factory = factory;
Configuration = Factory.Configuration;
LocalizedDisplayName = Configuration.Description;
IsBroken = !Configuration.IsRunnable();
BrokenEnvironmentHelpUrl = "https://go.microsoft.com/fwlink/?linkid=863373";
var withDb = factory as Interpreter.LegacyDB.IPythonInterpreterFactoryWithDatabase;
if (withDb != null)
{
withDb.IsCurrentChanged += Factory_IsCurrentChanged;
IsCheckingDatabase = withDb.IsCheckingDatabase;
IsCurrent = withDb.IsCurrent;
}
if (_service.IsConfigurable(Factory.Configuration.Id))
{
IsConfigurable = true;
}
Description = Factory.Configuration.Description;
IsDefault = (_service != null && _service.DefaultInterpreterId == Configuration.Id);
PrefixPath = Factory.Configuration.PrefixPath;
InterpreterPath = Factory.Configuration.InterpreterPath;
WindowsInterpreterPath = Factory.Configuration.WindowsInterpreterPath;
Extensions = new ObservableCollection <object>();
Extensions.Add(new EnvironmentPathsExtensionProvider());
if (IsConfigurable)
{
Extensions.Add(new ConfigurationExtensionProvider(_service, alwaysCreateNew: false));
}
CanBeDefault = Factory.CanBeDefault();
Company = _registry.GetProperty(Factory.Configuration.Id, CompanyKey) as string ?? "";
SupportUrl = _registry.GetProperty(Factory.Configuration.Id, SupportUrlKey) as string ?? "";
LocalizedHelpText = Company;
}
public Task SetInterpreterFactoryAsync(IPythonInterpreterFactory factory)
{
return(_workspace.SetInterpreterFactoryAsync(factory));
}
internal static IVsInteractiveWindow /*!*/ EnsureReplWindow(IServiceProvider serviceProvider, IPythonInterpreterFactory factory, PythonProjectNode project)
{
var compModel = serviceProvider.GetComponentModel();
var provider = compModel.GetService <InteractiveWindowProvider>();
string replId = PythonReplEvaluatorProvider.GetReplId(factory, project);
var window = provider.FindReplWindow(replId);
if (window == null)
{
window = provider.CreateInteractiveWindow(
serviceProvider.GetPythonContentType(),
factory.Description + " Interactive",
typeof(PythonLanguageInfo).GUID,
replId
);
var toolWindow = window as ToolWindowPane;
if (toolWindow != null)
{
toolWindow.BitmapImageMoniker = KnownMonikers.PYInteractiveWindow;
}
var pyService = serviceProvider.GetPythonToolsService();
window.InteractiveWindow.SetSmartUpDown(pyService.GetInteractiveOptions(factory).ReplSmartHistory);
}
if (project != null && project.Interpreters.IsProjectSpecific(factory))
{
project.AddActionOnClose(window, BasePythonReplEvaluator.CloseReplWindow);
}
return(window);
}
public PythonAnalyzer(IPythonInterpreterFactory factory, IPythonInterpreter interpreter = null)
: this(factory, interpreter, null)
{
ReloadModulesAsync().WaitAndUnwrapExceptions();
}
public static bool CanBeDeleted(this IPythonInterpreterFactory factory)
{
return(factory.Configuration.Id.StartsWithOrdinal(CondaEnvironmentFactoryProvider.EnvironmentCompanyName));
}
public PythonEditor(
string content = null,
PythonLanguageVersion version = PythonLanguageVersion.V27,
MockVs vs = null,
IPythonInterpreterFactory factory = null,
VsProjectAnalyzer analyzer = null,
string filename = null
)
{
if (vs == null)
{
_disposeVS = true;
vs = new MockVs();
}
MockVsTextView view = null;
try {
AdvancedEditorOptions advancedOptions = null;
vs.InvokeSync(() => {
advancedOptions = vs.GetPyService().AdvancedOptions;
advancedOptions.AutoListMembers = true;
advancedOptions.AutoListIdentifiers = false;
});
AdvancedOptions = advancedOptions;
if (factory == null)
{
_disposeFactory = true;
factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
}
if (analyzer == null)
{
_disposeAnalyzer = true;
vs.InvokeSync(() => {
analyzer = new VsProjectAnalyzer(vs.ServiceProvider, factory);
});
var task = analyzer.ReloadTask;
if (task != null)
{
task.WaitAndUnwrapExceptions();
}
}
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
using (var mre = new ManualResetEventSlim()) {
EventHandler evt = (s, e) => mre.SetIfNotDisposed();
analyzer.AnalysisStarted += evt;
view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "", v => {
v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), analyzer);
}, filename);
try {
while (!mre.Wait(500, cts.Token) && !vs.HasPendingException)
{
}
analyzer.WaitForCompleteAnalysis(x => !cts.IsCancellationRequested && !vs.HasPendingException);
} catch (OperationCanceledException) {
} finally {
analyzer.AnalysisStarted -= evt;
}
if (cts.IsCancellationRequested)
{
Assert.Fail("Timed out waiting for code analysis");
}
vs.ThrowPendingException();
}
View = view;
view = null;
Analyzer = analyzer;
analyzer = null;
Factory = factory;
factory = null;
VS = vs;
vs = null;
} finally {
if (view != null)
{
view.Dispose();
}
if (analyzer != null && _disposeAnalyzer)
{
analyzer.Dispose();
}
if (factory != null && _disposeFactory)
{
var disp = factory as IDisposable;
if (disp != null)
{
disp.Dispose();
}
}
if (vs != null && _disposeVS)
{
vs.Dispose();
}
}
}
public void SetInterpreterFactory(IPythonInterpreterFactory factory)
{
}
public static async Task <IPythonInterpreterFactory> CreateAndAddFactory(
IServiceProvider site,
IInterpreterRegistryService registry,
IInterpreterOptionsService options,
PythonProjectNode project,
IPythonWorkspaceContext workspace,
string path,
IPythonInterpreterFactory baseInterp,
bool registerAsCustomEnv,
string customEnvName,
bool preferVEnv = false
)
{
if (site == null)
{
throw new ArgumentNullException(nameof(site));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
if (baseInterp == null)
{
throw new ArgumentNullException(nameof(baseInterp));
}
if (preferVEnv)
{
await CreateWithVEnv(site, baseInterp, path);
}
else
{
await CreateWithVirtualEnv(site, baseInterp, path);
}
if (registerAsCustomEnv)
{
GetVirtualEnvConfig(path, baseInterp, out string interpExe, out string winterpExe, out string pathVar);
var factory = await CustomEnv.CreateCustomEnv(
registry,
options,
path,
interpExe,
winterpExe,
pathVar,
baseInterp.Configuration.Architecture,
baseInterp.Configuration.Version,
customEnvName
);
if (factory != null)
{
if (project != null)
{
project.AddInterpreter(factory.Configuration.Id);
}
else if (workspace != null)
{
await workspace.SetInterpreterFactoryAsync(factory);
}
}
return(factory);
}
else
{
if (project != null)
{
return(project.AddVirtualEnvironment(registry, path, baseInterp));
}
else if (workspace != null)
{
// In workspaces, always store the path to the virtual env's python.exe
GetVirtualEnvConfig(path, baseInterp, out string interpExe, out string winterpExe, out string pathVar);
var workspaceFactoryProvider = site.GetComponentModel().GetService <WorkspaceInterpreterFactoryProvider>();
using (workspaceFactoryProvider?.SuppressDiscoverFactories(forceDiscoveryOnDispose: true)) {
var relativeInterpExe = PathUtils.GetRelativeFilePath(workspace.Location, interpExe);
await workspace.SetInterpreterAsync(relativeInterpExe);
}
var factory = workspaceFactoryProvider?
.GetInterpreterFactories()
.FirstOrDefault(f => PathUtils.IsSamePath(f.Configuration.InterpreterPath, interpExe));
return(factory);
}
else
{
return(null);
}
}
}
internal static async System.Threading.Tasks.Task OpenAtAsync(IServiceProvider site, IPythonInterpreterFactory interpreter, Type extension = null)
{
var service = (IPythonToolsToolWindowService)site?.GetService(typeof(IPythonToolsToolWindowService));
if (service == null)
{
Debug.Fail("Failed to get environment list window");
return;
}
var wnd = await service.GetWindowPaneAsync(typeof(InterpreterListToolWindow), true) as InterpreterListToolWindow;
if (!(wnd?.Content is ToolWindow envs))
{
Debug.Fail("Failed to get environment list window");
return;
}
ErrorHandler.ThrowOnFailure((wnd.Frame as IVsWindowFrame)?.Show() ?? 0);
if (extension == null)
{
SelectEnv(envs, interpreter, 3);
}
else
{
SelectEnvAndExt(envs, interpreter, extension, 3);
}
}
/// <summary>
/// Creates a new analyzer that is not ready for use. You must call and
/// wait for <see cref="ReloadModulesAsync"/> to complete before using.
/// </summary>
public static PythonAnalyzer Create(IPythonInterpreterFactory factory, IPythonInterpreter interpreter = null)
{
return(new PythonAnalyzer(factory, interpreter, null));
}
internal static bool IsCondaEnv(IPythonInterpreterFactory factory)
{
return(factory.Configuration.Id.StartsWithOrdinal(CondaEnvironmentFactoryProvider.FactoryProviderName + "|"));
}
public MockInterpreterOptionsService()
{
_providers = new List <IPythonInterpreterFactoryProvider>();
_noInterpretersValue = new MockPythonInterpreterFactory(new InterpreterConfiguration("2.7", "No Interpreters", version: new Version(2, 7)));
_packageManagers = new Dictionary <IPythonInterpreterFactory, IReadOnlyList <IPackageManager> >();
}
/// <summary>
/// Returns true if the provided interpreter was resolved when it was
/// loaded.
/// </summary>
/// <remarks>
/// This may return true even if <see cref="Contains"/> would return
/// false for the same interpreter.
/// </remarks>
public bool IsAvailable(IPythonInterpreterFactory factory)
{
return(factory != null &&
!(factory is NotFoundInterpreterFactory) &&
factory.Configuration != null);
}
/// <summary>
/// Executes the interpreter with the specified arguments. Any output is
/// captured and returned via the <see cref="ProcessOutput"/> object.
/// </summary>
internal static ProcessOutput Run(
this IPythonInterpreterFactory factory,
params string[] arguments)
{
return(ProcessOutput.RunHiddenAndCapture(factory.Configuration.InterpreterPath, arguments));
}
/// <summary>
/// Adds the specified factory to the project. If the factory was
/// created by this provider, it will be added as an Interpreter element
/// with full details. If the factory was not created by this provider,
/// it will be added as an InterpreterReference element with only the
/// ID and version.
/// </summary>
/// <param name="factory">The factory to add.</param>
public void AddInterpreter(IPythonInterpreterFactory factory, bool disposeInterpreter = false)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (_factories.ContainsKey(factory))
{
return;
}
MSBuild.ProjectItem item;
var derived = factory as DerivedInterpreterFactory;
if (derived != null)
{
var projectHome = PathUtils.GetAbsoluteDirectoryPath(_project.DirectoryPath, _project.GetPropertyValue("ProjectHome"));
var rootPath = PathUtils.EnsureEndSeparator(factory.Configuration.PrefixPath);
_rootPaths[factory.Id] = rootPath;
item = _project.AddItem(InterpreterItem,
PathUtils.GetRelativeDirectoryPath(projectHome, rootPath),
new Dictionary <string, string> {
{ IdKey, derived.Id.ToString("B") },
{ BaseInterpreterKey, derived.BaseInterpreter.Id.ToString("B") },
{ VersionKey, derived.BaseInterpreter.Configuration.Version.ToString() },
{ DescriptionKey, derived.Description },
{ InterpreterPathKey, PathUtils.GetRelativeFilePath(rootPath, derived.Configuration.InterpreterPath) },
{ WindowsPathKey, PathUtils.GetRelativeFilePath(rootPath, derived.Configuration.WindowsInterpreterPath) },
{ LibraryPathKey, PathUtils.GetRelativeDirectoryPath(rootPath, derived.Configuration.LibraryPath) },
{ PathEnvVarKey, derived.Configuration.PathEnvironmentVariable },
{ ArchitectureKey, derived.Configuration.Architecture.ToString() }
}).FirstOrDefault();
}
else if (_service.FindInterpreter(factory.Id, factory.Configuration.Version) != null)
{
// The interpreter exists globally, so add a reference.
item = _project.AddItem(InterpreterReferenceItem,
string.Format("{0:B}\\{1}", factory.Id, factory.Configuration.Version)
).FirstOrDefault();
}
else
{
// Can't find the interpreter anywhere else, so add its
// configuration to the project file.
var projectHome = PathUtils.GetAbsoluteDirectoryPath(_project.DirectoryPath, _project.GetPropertyValue("ProjectHome"));
var rootPath = PathUtils.EnsureEndSeparator(factory.Configuration.PrefixPath);
item = _project.AddItem(InterpreterItem,
PathUtils.GetRelativeDirectoryPath(projectHome, rootPath),
new Dictionary <string, string> {
{ IdKey, factory.Id.ToString("B") },
{ VersionKey, factory.Configuration.Version.ToString() },
{ DescriptionKey, factory.Description },
{ InterpreterPathKey, PathUtils.GetRelativeFilePath(rootPath, factory.Configuration.InterpreterPath) },
{ WindowsPathKey, PathUtils.GetRelativeFilePath(rootPath, factory.Configuration.WindowsInterpreterPath) },
{ LibraryPathKey, PathUtils.GetRelativeDirectoryPath(rootPath, factory.Configuration.LibraryPath) },
{ PathEnvVarKey, factory.Configuration.PathEnvironmentVariable },
{ ArchitectureKey, factory.Configuration.Architecture.ToString() }
}).FirstOrDefault();
}
lock (_factoriesLock) {
_factories[factory] = new FactoryInfo(item, disposeInterpreter);
}
OnInterpreterFactoriesChanged();
UpdateActiveInterpreter();
}
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 void AddPackageManagers(IPythonInterpreterFactory factory, IReadOnlyList <IPackageManager> packageManagers)
{
_packageManagers[factory] = packageManagers;
}
public Task <object> LockInterpreterAsync(IPythonInterpreterFactory factory, object moniker, TimeSpan timeout)
{
throw new NotImplementedException();
}
private static bool AreEqual(IPythonInterpreterFactory factory, Guid id, Version version)
{
return(factory != null && factory.Id.Equals(id) && (factory.Configuration.Version == null || factory.Configuration.Version.Equals(version)));
}
public MockInterpreterOptionsService()
{
_providers = new List <IPythonInterpreterFactoryProvider>();
_noInterpretersValue = new MockPythonInterpreterFactory(new InterpreterConfiguration("2.7", "No Interpreters", version: new Version(2, 7)));
}
protected override List <string> GetScrapeArguments(IPythonInterpreterFactory factory)
{
// Cannot scrape this module
return(null);
}
public bool IsInterpreterGeneratingDatabase(IPythonInterpreterFactory interpreter)
{
throw new NotImplementedException();
}
