public CJInterpreterFactory(Version version, Guid id, string description, string jPath, string jvPath, string pathEnvVar, ProcessorArchitecture arch)
{
if (version == default(Version)) {
version = new Version(6, 0, 2);
}
_description = description;
_id = id;
_config = new CJInterpreterConfiguration(jPath, jvPath, pathEnvVar, arch, version);
}
public PythonInterpreterInformation(
InterpreterConfiguration configuration,
string vendor,
string vendorUrl,
string supportUrl
) {
Configuration = configuration;
Vendor = vendor;
VendorUrl = vendorUrl;
SupportUrl = supportUrl;
}
public void RemovedModule() {
var id = Guid.NewGuid().ToString();
var config = new InterpreterConfiguration(id, id, version: new Version(3, 5));
var fact = new MockPythonInterpreterFactory(config);
var interp = new MockPythonInterpreter(fact);
var modules = new ModuleTable(null, interp);
var orig = modules.Select(kv => kv.Key).ToSet();
interp.AddModule("test", new MockPythonModule("test"));
ModuleReference modref;
Assert.IsTrue(modules.TryImport("test", out modref));
interp.RemoveModule("test", retainName: true);
modules.ReInit();
Assert.IsFalse(modules.TryImport("test", out modref));
}
private async Task BuiltinScrape(InterpreterConfiguration configuration)
{
configuration.AssertInstalled();
var moduleUri = TestData.GetDefaultModuleUri();
var moduleDirectory = Path.GetDirectoryName(moduleUri.LocalPath);
var services = await CreateServicesAsync(moduleDirectory, configuration);
var interpreter = services.GetService <IPythonInterpreter>();
var mod = interpreter.ModuleResolution.GetOrLoadModule(interpreter.ModuleResolution.BuiltinModuleName);
await services.GetService <IPythonAnalyzer>().WaitForCompleteAnalysisAsync();
Assert.IsInstanceOfType(mod, typeof(BuiltinsPythonModule));
var modPath = interpreter.ModuleResolution.ModuleCache.GetCacheFilePath(interpreter.Configuration.InterpreterPath);
var doc = mod as IDocument;
var errors = doc.GetParseErrors().ToArray();
foreach (var err in errors)
{
Console.WriteLine(err);
}
Assert.AreEqual(0, errors.Count(), "Parse errors occurred");
var ast = await doc.GetAstAsync();
var seen = new HashSet <string>();
foreach (var stmt in ((SuiteStatement)ast.Body).Statements)
{
if (stmt is ClassDefinition cd)
{
Assert.IsTrue(seen.Add(cd.Name), $"Repeated use of {cd.Name} at index {cd.StartIndex} in {modPath}");
}
else if (stmt is FunctionDefinition fd)
{
Assert.IsTrue(seen.Add(fd.Name), $"Repeated use of {fd.Name} at index {fd.StartIndex} in {modPath}");
}
else if (stmt is AssignmentStatement assign && assign.Left.FirstOrDefault() is NameExpression n)
{
Assert.IsTrue(seen.Add(n.Name), $"Repeated use of {n.Name} at index {n.StartIndex} in {modPath}");
}
}
// Ensure we can get all the builtin types
foreach (BuiltinTypeId v in Enum.GetValues(typeof(BuiltinTypeId)))
{
var type = interpreter.GetBuiltinType(v);
type.Should().NotBeNull().And.BeAssignableTo <IPythonType>($"Did not find {v}");
type.IsBuiltin.Should().BeTrue();
}
// Ensure we cannot see or get builtin types directly
mod.GetMemberNames().Should().NotContain(Enum.GetNames(typeof(BuiltinTypeId)).Select(n => $"__{n}"));
foreach (var id in Enum.GetNames(typeof(BuiltinTypeId)))
{
mod.GetMember($"__{id}").Should().BeNull(id);
}
}
public PythonVersion(InterpreterConfiguration config, bool ironPython = false, bool cPython = false)
{
Configuration = config;
IsCPython = cPython;
IsIronPython = ironPython;
}
public void InterpreterUnloaded(object context, InterpreterConfiguration factory)
{
}
private async Task <IReadOnlyList <DiagnosticsEntry> > LintAsync(string code, InterpreterConfiguration configuration = null)
{
var analysis = await GetAnalysisAsync(code, configuration ?? PythonVersions.LatestAvailable3X);
var a = Services.GetService <IPythonAnalyzer>();
return(a.LintModule(analysis.Document));
}
/// <summary>
/// Create a PythonInterpreterView with values from an IPythonInterpreterFactory.
/// </summary>
public PythonInterpreterView(InterpreterConfiguration config)
{
_name = config.Description;
_id = config.Id;
_path = config.InterpreterPath;
}
public AstPythonInterpreterFactory(InterpreterConfiguration config, InterpreterFactoryCreationOptions options)
: this(config, options, string.IsNullOrEmpty(options?.DatabasePath))
{
}
private EnvironmentView(string id, string localizedName)
{
Configuration = new InterpreterConfiguration(id, id);
Description = LocalizedDisplayName = localizedName;
Extensions = new ObservableCollection <object>();
}
public string AddConfigurableInterpreter(string name, InterpreterConfiguration config)
{
throw new NotImplementedException();
}
public AstModuleResolution(IPythonInterpreter interpreter, ConcurrentDictionary <string, IPythonModule> modules, AstModuleCache astModuleCache, InterpreterConfiguration configuration, AnalysisLogWriter log)
{
_interpreter = interpreter;
_modules = modules;
_astModuleCache = astModuleCache;
_configuration = configuration;
_log = log;
_requireInitPy = ModulePath.PythonVersionRequiresInitPyFiles(_configuration.Version);
}
/// <summary>
/// Returns true if the configuration can be run. This checks whether
/// the configured InterpreterPath value is an actual file.
/// </summary>
public static bool IsRunnable(this InterpreterConfiguration config)
{
return(config != null &&
!InterpreterRegistryConstants.IsNoInterpretersFactory(config.Id) &&
File.Exists(config.InterpreterPath));
}
/// <summary>
/// Returns <c>true</c> if the factory should appear in the UI.
/// </summary>
/// <remarks>New in 2.2</remarks>
public static bool IsUIVisible(this InterpreterConfiguration config)
{
return(config is VisualStudioInterpreterConfiguration vsConfig &&
!vsConfig.UIMode.HasFlag(InterpreterUIMode.Hidden));
}
public static string GetWindowsInterpreterPath(this InterpreterConfiguration config)
{
return(config != null ? ((VisualStudioInterpreterConfiguration)config).WindowsInterpreterPath : null);
}
/// <summary>
/// Returns <c>true</c> if the factory can be automatically selected as
/// the default interpreter.
/// </summary>
/// <remarks>New in 2.2</remarks>
public static bool CanBeAutoDefault(this InterpreterConfiguration config)
{
return(config is VisualStudioInterpreterConfiguration vsConfig &&
!vsConfig.UIMode.HasFlag(InterpreterUIMode.CannotBeDefault) &&
!vsConfig.UIMode.HasFlag(InterpreterUIMode.CannotBeAutoDefault));
}
public CPythonInterpreterFactory(InterpreterConfiguration configuration, InterpreterFactoryCreationOptions options) :
base(configuration, options)
{
}
internal static InterpreterFactoryCreationOptions GetCreationOptions(IServiceProvider site, InterpreterConfiguration config)
{
return(new InterpreterFactoryCreationOptions {
});
}
internal static IVsInteractiveWindow /*!*/ EnsureReplWindow(IServiceProvider serviceProvider, InterpreterConfiguration config, PythonProjectNode project)
{
var compModel = serviceProvider.GetComponentModel();
var provider = compModel.GetService <InteractiveWindowProvider>();
var vsProjectContext = compModel.GetService <VsProjectContextProvider>();
var projectId = project != null?PythonReplEvaluatorProvider.GetEvaluatorId(project) : null;
var configId = config != null?PythonReplEvaluatorProvider.GetEvaluatorId(config) : null;
if (config?.IsRunnable() == false)
{
throw new MissingInterpreterException(
Strings.MissingEnvironment.FormatUI(config.Description, config.Version)
);
}
IVsInteractiveWindow window;
// If we find an open window for the project, prefer that to a per-config one
if (!string.IsNullOrEmpty(projectId))
{
window = provider.Open(
projectId,
e => ((e as SelectableReplEvaluator)?.Evaluator as PythonCommonInteractiveEvaluator)?.AssociatedProjectHasChanged != true
);
if (window != null)
{
return(window);
}
}
// If we find an open window for the configuration, return that
if (!string.IsNullOrEmpty(configId))
{
window = provider.Open(configId);
if (window != null)
{
return(window);
}
}
// No window found, so let's create one
if (!string.IsNullOrEmpty(projectId))
{
window = provider.Create(projectId);
project.AddActionOnClose(window, w => InteractiveWindowProvider.CloseIfEvaluatorMatches(w, projectId));
}
else if (!string.IsNullOrEmpty(configId))
{
window = provider.Create(configId);
}
else
{
var interpService = compModel.GetService <IInterpreterOptionsService>();
window = provider.Create(PythonReplEvaluatorProvider.GetEvaluatorId(interpService.DefaultInterpreter.Configuration));
}
return(window);
}
protected Task <IServiceManager> CreateServicesAsync(InterpreterConfiguration configuration, IServiceManager sm = null) => CreateServicesAsync(TestData.GetTestSpecificRootUri().AbsolutePath, configuration, sm);
protected Task <IServiceManager> CreateServicesAsync(InterpreterConfiguration configuration, string[] searchPaths = null) => CreateServicesAsync(TestData.GetTestSpecificRootPath(), configuration, null, null, searchPaths);
private static bool HasPrefixName(InterpreterConfiguration config, string name)
{
var current = PathUtils.GetFileOrDirectoryName(config.PrefixPath);
return(string.CompareOrdinal(current, name) == 0);
}
internal AstPythonInterpreterFactory(Dictionary <string, object> properties) :
this(InterpreterConfiguration.FromDictionary(properties), InterpreterFactoryCreationOptions.FromDictionary(properties))
{
}
public Task <Server> CreateServer(string rootPath, InterpreterConfiguration configuration = null, Dictionary <Uri, PublishDiagnosticsEventArgs> diagnosticEvents = null)
{
return(CreateServer(string.IsNullOrEmpty(rootPath) ? null : new Uri(rootPath), configuration ?? Default, diagnosticEvents));
}
internal static void ShowOptionPage(System.IServiceProvider serviceProvider, Type dialogPage, InterpreterConfiguration interpreter) {
if (dialogPage == typeof(PythonInterpreterOptionsPage)) {
PythonInterpreterOptionsPage.NextOptionsSelection = interpreter;
} else if (dialogPage == typeof(PythonInteractiveOptionsPage)) {
PythonInteractiveOptionsPage.NextOptionsSelection = interpreter;
} else {
throw new InvalidOperationException();
}
serviceProvider.ShowOptionsPage(dialogPage);
}
internal static bool IsIronPython(this InterpreterConfiguration config)
{
return(config.Id.StartsWithOrdinal("IronPython|", ignoreCase: true));
}
public UnavailableFactory(string id, string version)
{
Id = Guid.Parse(id);
Configuration = new InterpreterConfiguration(Version.Parse(version));
}
public async Task <InitializeResult> InitializeAsync(InitializeParams @params, CancellationToken cancellationToken)
{
_disposableBag.ThrowIfDisposed();
_clientCaps = @params.capabilities;
_log = _services.GetService <ILogger>();
_services.AddService(new DiagnosticsService(_services));
var cacheFolderPath = @params.initializationOptions.cacheFolderPath;
var fs = _services.GetService <IFileSystem>();
if (cacheFolderPath != null && !fs.DirectoryExists(cacheFolderPath))
{
_log?.Log(TraceEventType.Warning, Resources.Error_InvalidCachePath);
cacheFolderPath = null;
}
var analyzer = new PythonAnalyzer(_services, cacheFolderPath);
_services.AddService(analyzer);
analyzer.AnalysisComplete += OnAnalysisComplete;
_disposableBag.Add(() => analyzer.AnalysisComplete -= OnAnalysisComplete);
_services.AddService(new RunningDocumentTable(_services));
_rdt = _services.GetService <IRunningDocumentTable>();
_rootDir = @params.rootUri != null? @params.rootUri.ToAbsolutePath() : @params.rootPath;
if (_rootDir != null)
{
_rootDir = PathUtils.NormalizePath(_rootDir);
_rootDir = PathUtils.TrimEndSeparator(_rootDir);
}
Version.TryParse(@params.initializationOptions.interpreter.properties?.Version, out var version);
var configuration = new InterpreterConfiguration(null, null,
interpreterPath: @params.initializationOptions.interpreter.properties?.InterpreterPath,
version: version
)
{
// 1) Split on ';' to support older VS Code extension versions which send paths as a single entry separated by ';'. TODO: Eventually remove.
// 2) Normalize paths.
// 3) If a path isn't rooted, then root it relative to the workspace root. If _rootDir is null, then accept the path as-is.
// 4) Trim off any ending separator for a consistent style.
// 5) Filter out any entries which are the same as the workspace root; they are redundant. Also ignore "/" to work around the extension (for now).
// 6) Remove duplicates.
SearchPaths = @params.initializationOptions.searchPaths
.Select(p => p.Split(';', StringSplitOptions.RemoveEmptyEntries)).SelectMany()
.Select(PathUtils.NormalizePath)
.Select(p => _rootDir == null || Path.IsPathRooted(p) ? p : Path.GetFullPath(p, _rootDir))
.Select(PathUtils.TrimEndSeparator)
.Where(p => !string.IsNullOrWhiteSpace(p) && p != "/" && !p.PathEquals(_rootDir))
.Distinct(PathEqualityComparer.Instance)
.ToList(),
TypeshedPath = @params.initializationOptions.typeStubSearchPaths.FirstOrDefault()
};
_interpreter = await PythonInterpreter.CreateAsync(configuration, _rootDir, _services, cancellationToken);
_services.AddService(_interpreter);
var fileSystem = _services.GetService <IFileSystem>();
_indexManager = new IndexManager(fileSystem, _interpreter.LanguageVersion, _rootDir,
@params.initializationOptions.includeFiles,
@params.initializationOptions.excludeFiles,
_services.GetService <IIdleTimeService>());
_indexManager.IndexWorkspace().DoNotWait();
_services.AddService(_indexManager);
_disposableBag.Add(_indexManager);
DisplayStartupInfo();
_completionSource = new CompletionSource(
ChooseDocumentationSource(_clientCaps?.textDocument?.completion?.completionItem?.documentationFormat),
Settings.completion
);
_hoverSource = new HoverSource(
ChooseDocumentationSource(_clientCaps?.textDocument?.hover?.contentFormat)
);
var sigInfo = _clientCaps?.textDocument?.signatureHelp?.signatureInformation;
_signatureSource = new SignatureSource(
ChooseDocumentationSource(sigInfo?.documentationFormat),
sigInfo?.parameterInformation?.labelOffsetSupport == true
);
return(GetInitializeResult());
}
private async Task FullStdLibTest(InterpreterConfiguration configuration, params string[] skipModules)
{
configuration.AssertInstalled();
var moduleUri = TestData.GetDefaultModuleUri();
var moduleDirectory = Path.GetDirectoryName(moduleUri.LocalPath);
var services = await CreateServicesAsync(moduleDirectory, configuration);
var interpreter = services.GetService <IPythonInterpreter>();
var modules = ModulePath.GetModulesInLib(configuration.LibraryPath, configuration.SitePackagesPath).ToList();
var skip = new HashSet <string>(skipModules);
skip.UnionWith(new[] {
@"matplotlib.backends._backend_gdk",
@"matplotlib.backends._backend_gtkagg",
@"matplotlib.backends._gtkagg",
"test.test_pep3131",
"test.test_unicode_identifiers",
"test.test_super" // nonlocal syntax error
});
skip.UnionWith(modules.Select(m => m.FullName)
.Where(n => n.StartsWith(@"test.badsyntax") || n.StartsWith("test.bad_coding")));
var anySuccess = false;
var anyExtensionSuccess = false;
var anyExtensionSeen = false;
var anyParseError = false;
foreach (var m in skip)
{
((MainModuleResolution)interpreter.ModuleResolution).AddUnimportableModule(m);
}
var set = modules
.Where(m => !skip.Contains(m.ModuleName))
.GroupBy(m => {
var i = m.FullName.IndexOf('.');
return(i <= 0 ? m.FullName : m.FullName.Remove(i));
})
.SelectMany(g => g.Select(m => Tuple.Create(m, m.ModuleName)))
.ToArray();
set = set.Where(x => x.Item2 != null && x.Item2.Contains("grammar")).ToArray();
foreach (var r in set)
{
interpreter.ModuleResolution.GetOrLoadModule(r.Item2);
}
await services.GetService <IPythonAnalyzer>().WaitForCompleteAnalysisAsync();
foreach (var r in set)
{
var modName = r.Item1;
var mod = interpreter.ModuleResolution.GetOrLoadModule(r.Item2);
anyExtensionSeen |= modName.IsNativeExtension;
switch (mod)
{
case null:
Trace.TraceWarning("failed to import {0} from {1}", modName.ModuleName, modName.SourceFile);
break;
case CompiledPythonModule compiledPythonModule:
var errors = compiledPythonModule.GetParseErrors().ToArray();
if (errors.Any())
{
anyParseError = true;
Trace.TraceError("Parse errors in {0}", modName.SourceFile);
foreach (var e in errors)
{
Trace.TraceError(e.Message);
}
}
else
{
anySuccess = true;
anyExtensionSuccess |= modName.IsNativeExtension;
}
break;
case IPythonModule _: {
var filteredErrors = ((IDocument)mod).GetParseErrors().Where(e => !e.Message.Contains("encoding problem")).ToArray();
if (filteredErrors.Any())
{
// Do not fail due to errors in installed packages
if (!mod.FilePath.Contains("site-packages"))
{
anyParseError = true;
}
Trace.TraceError("Parse errors in {0}", modName.SourceFile);
foreach (var e in filteredErrors)
{
Trace.TraceError(e.Message);
}
}
else
{
anySuccess = true;
anyExtensionSuccess |= modName.IsNativeExtension;
}
break;
}
}
}
Assert.IsTrue(anySuccess, "failed to import any modules at all");
Assert.IsTrue(anyExtensionSuccess || !anyExtensionSeen, "failed to import all extension modules");
Assert.IsFalse(anyParseError, "parse errors occurred");
}
public InterpreterOptions(PythonToolsService pyService, InterpreterConfiguration config)
{
_pyService = pyService;
_config = config;
}
private PythonInterpreter(InterpreterConfiguration configuration)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
LanguageVersion = Configuration.Version.ToLanguageVersion();
UnknownType = _builtinTypes[BuiltinTypeId.Unknown];
}
public void LaunchDebugTarget(IWorkspace workspace, IServiceProvider serviceProvider, DebugLaunchActionContext debugLaunchActionContext)
{
var registry = serviceProvider.GetComponentModel().GetService <IInterpreterRegistryService>();
var settings = debugLaunchActionContext.LaunchConfiguration;
var scriptName = settings.GetValue(ScriptNameKey, string.Empty);
var debug = !settings.GetValue("noDebug", false);
var interpreterVal = settings.GetValue(InterpreterKey, string.Empty);
var path = interpreterVal;
InterpreterConfiguration config = null;
if (string.IsNullOrEmpty(scriptName))
{
throw new InvalidOperationException(Strings.DebugLaunchScriptNameMissing);
}
if (!string.IsNullOrEmpty(path) && !DefaultInterpreterValue.Equals(path, StringComparison.OrdinalIgnoreCase))
{
if (PathUtils.IsValidPath(path) && !Path.IsPathRooted(path))
{
path = workspace.MakeRooted(path);
}
if (File.Exists(path))
{
config = registry.Configurations.FirstOrDefault(c => c.InterpreterPath.Equals(path, StringComparison.OrdinalIgnoreCase)) ??
new VisualStudioInterpreterConfiguration("Custom", path, PathUtils.GetParent(path), path);
}
else
{
config = registry.FindConfiguration(interpreterVal);
}
}
else
{
var options = serviceProvider.GetComponentModel().GetService <IInterpreterOptionsService>();
var interpreter = workspace.GetInterpreterFactory(registry, options);
interpreter.ThrowIfNotRunnable();
config = interpreter.Configuration;
path = config.InterpreterPath;
}
if (!File.Exists(path))
{
throw new InvalidOperationException(Strings.DebugLaunchInterpreterMissing_Path.FormatUI(path));
}
var searchPaths = workspace.GetAbsoluteSearchPaths().ToList();
var environment = new Dictionary <string, string>();
if (settings.TryGetValue <IPropertySettings>(EnvKey, out IPropertySettings envSettings))
{
foreach (var keyVal in envSettings)
{
environment[keyVal.Key] = keyVal.Value.ToString();
}
}
string workingDir = settings.GetValue(WorkingDirectoryKey, string.Empty);
if (string.IsNullOrEmpty(workingDir))
{
workingDir = workspace.MakeRooted(".");
}
else if (PathUtils.IsValidPath(workingDir) && !Path.IsPathRooted(workingDir))
{
workingDir = workspace.MakeRooted(workingDir);
}
var launchConfig = new LaunchConfiguration(config)
{
InterpreterPath = config == null ? path : null,
InterpreterArguments = settings.GetValue(InterpreterArgumentsKey, string.Empty),
ScriptName = Path.IsPathRooted(scriptName) ? scriptName : Path.Combine(workingDir, scriptName),
ScriptArguments = settings.GetValue(ScriptArgumentsKey, string.Empty),
WorkingDirectory = workingDir,
SearchPaths = searchPaths,
Environment = environment,
};
launchConfig.LaunchOptions[PythonConstants.EnableNativeCodeDebugging] = settings.GetValue(NativeDebuggingKey, false).ToString();
IProjectLauncher launcher = null;
var browserUrl = settings.GetValue(WebBrowserUrlKey, string.Empty);
if (!string.IsNullOrEmpty(browserUrl))
{
launchConfig.LaunchOptions[PythonConstants.WebBrowserUrlSetting] = browserUrl;
launcher = new PythonWebLauncher(serviceProvider, launchConfig, launchConfig, launchConfig);
}
(launcher ?? new DefaultPythonLauncher(serviceProvider, launchConfig)).LaunchProject(debug);
}
public CPythonInterpreterFactory(InterpreterConfiguration configuration, InterpreterFactoryCreationOptions options)
: base(configuration, options.WatchLibraryForNewModules)
{
}
internal static string GetTemporaryId(string key, InterpreterConfiguration config)
{
return(GetEvaluatorId(config) + ";" + key);
}
