private static PythonVersion GetJythonVersion(PythonLanguageVersion version) {
var candidates = new List<DirectoryInfo>();
var ver = version.ToVersion();
var path1 = string.Format("jython{0}{1}*", ver.Major, ver.Minor);
var path2 = string.Format("jython{0}.{1}*", ver.Major, ver.Minor);
foreach (var drive in DriveInfo.GetDrives()) {
if (drive.DriveType != DriveType.Fixed) {
continue;
}
try {
candidates.AddRange(drive.RootDirectory.EnumerateDirectories(path1));
candidates.AddRange(drive.RootDirectory.EnumerateDirectories(path2));
} catch {
}
}
foreach (var dir in candidates) {
var interpreter = dir.EnumerateFiles("jython.bat").FirstOrDefault();
if (interpreter == null) {
continue;
}
var libPath = dir.EnumerateDirectories("Lib").FirstOrDefault();
if (libPath == null || !libPath.EnumerateFiles("site.py").Any()) {
continue;
}
return new PythonVersion(new InterpreterConfiguration(
CPythonInterpreterFactoryConstants.GetInterpreterId(
"Jython",
version.ToVersion().ToString()
),
string.Format("Jython {0}", version.ToVersion()),
dir.FullName,
interpreter.FullName,
version: version.ToVersion()
));
}
return null;
}
private SaveLoadResult SaveLoad(PythonLanguageVersion version, params AnalysisModule[] modules) {
IPythonProjectEntry[] entries = new IPythonProjectEntry[modules.Length];
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var interp = fact.CreateInterpreter();
var dbFolder = TestData.GetTempPath(randomSubPath: true);
Directory.CreateDirectory(dbFolder);
var state = new PythonAnalysis(fact, interp, SharedDatabaseState.BuiltinName2x);
state.CreateProjectOnDisk = true;
for (int i = 0; i < modules.Length; i++) {
state.AddModule(modules[i].ModuleName, modules[i].Code, modules[i].Filename);
}
state.WaitForAnalysis();
new SaveAnalysis().Save(state.Analyzer, dbFolder);
File.Copy(
Path.Combine(PythonTypeDatabase.BaselineDatabasePath, "__builtin__.idb"),
Path.Combine(dbFolder, "__builtin__.idb"),
true
);
var loadFactory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(
version.ToVersion(),
null,
dbFolder
);
return new SaveLoadResult(CreateAnalyzer(loadFactory), state.CodeFolder);
}
private static PythonVersion GetCPythonVersion(PythonLanguageVersion version, InterpreterArchitecture arch) {
var res = _foundInRegistry.FirstOrDefault(ii =>
ii.Configuration.Id.StartsWith("Global|PythonCore|") &&
ii.Configuration.Architecture == arch &&
ii.Configuration.Version == version.ToVersion()
);
if (res != null) {
return new PythonVersion(res.Configuration, cPython: true);
}
var ver = version.ToVersion();
var tag = ver + (arch == InterpreterArchitecture.x86 ? "-32" : "");
foreach (var path in new[] {
string.Format("Python{0}{1}", ver.Major, ver.Minor),
string.Format("Python{0}{1}_{2}", ver.Major, ver.Minor, arch.ToString("x")),
string.Format("Python{0}{1}-{2}", ver.Major, ver.Minor, arch.ToString("#")),
string.Format("Python{0}{1}_{2}", ver.Major, ver.Minor, arch.ToString("#")),
}) {
var prefixPath = Path.Combine(Environment.GetEnvironmentVariable("SystemDrive"), "\\", path);
var exePath = Path.Combine(prefixPath, CPythonInterpreterFactoryConstants.ConsoleExecutable);
var procArch = (arch == InterpreterArchitecture.x86) ? ProcessorArchitecture.X86 :
(arch == InterpreterArchitecture.x64) ? ProcessorArchitecture.Amd64 :
ProcessorArchitecture.None;
if (procArch == Microsoft.PythonTools.Infrastructure.NativeMethods.GetBinaryType(path)) {
return new PythonVersion(new InterpreterConfiguration(
CPythonInterpreterFactoryConstants.GetInterpreterId("PythonCore", tag),
"Python {0} {1}".FormatInvariant(arch, ver),
prefixPath,
exePath,
pathVar: CPythonInterpreterFactoryConstants.PathEnvironmentVariableName,
arch: arch,
version: ver
));
}
}
return null;
}
private static IPythonModule Parse(string path, PythonLanguageVersion version) {
var interpreter = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()).CreateInterpreter();
if (!Path.IsPathRooted(path)) {
path = TestData.GetPath(Path.Combine("TestData", "AstAnalysis", path));
}
return AstPythonModule.FromFile(interpreter, path, version);
}
public ClassifierHelper(string code, PythonLanguageVersion version)
{
_vs = new MockVs();
var reg = _vs.ContentTypeRegistry;
var providers = _vs.ComponentModel.GetExtensions <IClassifierProvider>().ToArray();
_provider1 = providers.OfType <PythonClassifierProvider>().Single();
_provider2 = providers.OfType <PythonAnalysisClassifierProvider>().Single();
var factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
_analyzer = new VsProjectAnalyzer(_vs.ServiceProvider, factory, new[] { factory });
_view = _vs.CreateTextView(PythonCoreConstants.ContentType, code, v => {
v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), _analyzer);
});
}
internal PythonAnalyzer AnalyzeDir(string dir, PythonLanguageVersion version = PythonLanguageVersion.V27, IEnumerable<string> excludeDirectories = null, CancellationToken? cancel = null) {
List<string> files = new List<string>();
try {
ISet<string> excluded = null;
if (excludeDirectories != null) {
excluded = new HashSet<string>(excludeDirectories, StringComparer.InvariantCultureIgnoreCase);
}
CollectFiles(dir, files, excluded);
} catch (DirectoryNotFoundException) {
return null;
}
List<FileStreamReader> sourceUnits = new List<FileStreamReader>();
foreach (string file in files) {
sourceUnits.Add(
new FileStreamReader(file)
);
}
Stopwatch sw = new Stopwatch();
sw.Start();
long start0 = sw.ElapsedMilliseconds;
// Explicitly specify the builtins name because we are using a 2.7
// interpreter for all versions.
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var projectState = new PythonAnalyzer(fact, fact.CreateInterpreter(), "__builtin__");
projectState.ReloadModulesAsync().WaitAndUnwrapExceptions();
projectState.Limits = AnalysisLimits.GetStandardLibraryLimits();
var modules = new List<IPythonProjectEntry>();
foreach (var sourceUnit in sourceUnits) {
try {
modules.Add(projectState.AddModule(
ModulePath.FromFullPath(sourceUnit.Path).ModuleName,
sourceUnit.Path,
null
));
} catch (ArgumentException) {
// Invalid module name, so skip the module
}
}
long start1 = sw.ElapsedMilliseconds;
Trace.TraceInformation("AddSourceUnit: {0} ms", start1 - start0);
var nodes = new List<Microsoft.PythonTools.Parsing.Ast.PythonAst>();
for (int i = 0; i < modules.Count; i++) {
PythonAst ast = null;
try {
var sourceUnit = sourceUnits[i];
ast = Parser.CreateParser(sourceUnit, version).ParseFile();
} catch (Exception) {
}
nodes.Add(ast);
}
long start2 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Parse: {0} ms", start2 - start1);
for (int i = 0; i < modules.Count; i++) {
var ast = nodes[i];
if (ast != null) {
modules[i].UpdateTree(ast, null);
}
}
long start3 = sw.ElapsedMilliseconds;
for (int i = 0; i < modules.Count; i++) {
Trace.TraceInformation("Analyzing {1}: {0} ms", sw.ElapsedMilliseconds - start3, sourceUnits[i].Path);
var ast = nodes[i];
if (ast != null) {
modules[i].Analyze(cancel ?? CancellationToken.None, true);
}
}
if (modules.Count > 0) {
Trace.TraceInformation("Analyzing queue");
modules[0].AnalysisGroup.AnalyzeQueuedEntries(cancel ?? CancellationToken.None);
}
long start4 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Analyze: {0} ms", start4 - start3);
return projectState;
}
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 {
AdvancedOptions = vs.GetPyService().AdvancedOptions;
AdvancedOptions.AutoListMembers = true;
AdvancedOptions.AutoListIdentifiers = false;
if (factory == null) {
_disposeFactory = true;
factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
}
if (analyzer == null) {
_disposeAnalyzer = true;
analyzer = new VsProjectAnalyzer(vs.ServiceProvider, factory);
var task = analyzer.ReloadTask;
if (task != null) {
task.WaitAndUnwrapExceptions();
}
}
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
using (var mre = new ManualResetEventSlim()) {
EventHandler evt = (s, e) => mre.Set();
analyzer.AnalysisStarted += evt;
view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "", v => {
v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), analyzer);
}, filename);
try {
mre.Wait(cts.Token);
analyzer.WaitForCompleteAnalysis(x => !cts.IsCancellationRequested);
} catch (OperationCanceledException) {
} finally {
analyzer.AnalysisStarted -= evt;
}
if (cts.IsCancellationRequested) {
Assert.Fail("Timed out waiting for code analysis");
}
}
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 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 {
AdvancedOptions = vs.GetPyService().AdvancedOptions;
AdvancedOptions.AutoListMembers = true;
AdvancedOptions.AutoListIdentifiers = false;
if (factory == null)
{
_disposeFactory = true;
factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
}
if (analyzer == null)
{
_disposeAnalyzer = true;
analyzer = new VsProjectAnalyzer(vs.ServiceProvider, factory, new[] { factory });
var task = analyzer.ReloadTask;
if (task != null)
{
task.WaitAndUnwrapExceptions();
}
}
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
using (var mre = new ManualResetEventSlim()) {
EventHandler evt = (s, e) => mre.Set();
analyzer.AnalysisStarted += evt;
view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "", v => {
v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), analyzer);
}, filename);
try {
mre.Wait(cts.Token);
analyzer.WaitForCompleteAnalysis(x => !cts.IsCancellationRequested);
} catch (OperationCanceledException) {
} finally {
analyzer.AnalysisStarted -= evt;
}
if (cts.IsCancellationRequested)
{
Assert.Fail("Timed out waiting for code analysis");
}
}
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();
}
}
}
private static InterpreterConfiguration GetCPythonVersion(PythonLanguageVersion version, InterpreterArchitecture arch)
{
return(PythonInstallPathResolver.Instance.GetPythonConfiguration("Global|PythonCore|", arch, version.ToVersion()));
}
public PythonAnalysis(PythonLanguageVersion version)
: this(InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()))
{
}
private static InterpreterConfiguration GetAnacondaVersion(PythonLanguageVersion version, InterpreterArchitecture arch) => PythonInstallPathResolver.Instance.GetCondaPythonConfiguration(arch, version.ToVersion());
public PythonAnalysis ProcessText(
string text,
PythonLanguageVersion version = PythonLanguageVersion.None,
bool allowParseErrors = false
)
{
// TODO: Analyze against multiple versions when the version is None
if (version == PythonLanguageVersion.None)
{
return(ProcessTextV2(text, allowParseErrors));
}
var analysis = CreateAnalyzer(InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()), allowParseErrors);
analysis.AddModule("test-module", text);
analysis.WaitForAnalysis();
return(analysis);
}
private static IPythonModule Parse(string path, PythonLanguageVersion version)
{
var interpreter = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()).CreateInterpreter();
if (!Path.IsPathRooted(path))
{
path = TestData.GetPath(Path.Combine("TestData", "AstAnalysis", path));
}
return(AstPythonModule.FromFile(interpreter, path, version));
}
public PythonEditor(
string content = null,
PythonLanguageVersion version = PythonLanguageVersion.V27,
MockVs vs = null,
IPythonInterpreterFactory factory = null,
VsProjectAnalyzer analyzer = null,
string filename = null,
bool?inProcAnalyzer = 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)
{
vs.InvokeSync(() => {
factory = vs.ComponentModel.GetService <IInterpreterRegistryService>()
.Interpreters
.FirstOrDefault(c => c.GetLanguageVersion() == version && c.Configuration.Id.StartsWith("Global|PythonCore"));
if (factory != null)
{
Console.WriteLine($"Using interpreter {factory.Configuration.InterpreterPath}");
}
});
if (factory == null)
{
_disposeFactory = true;
factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
Console.WriteLine("Using analysis-only interpreter");
}
}
if (analyzer == null)
{
_disposeAnalyzer = true;
analyzer = vs.InvokeTask(() => VsProjectAnalyzer.CreateForTestsAsync(vs.ComponentModel.GetService <PythonEditorServices>(), factory, inProcAnalyzer ?? Debugger.IsAttached));
}
if (string.IsNullOrEmpty(filename))
{
do
{
filename = PathUtils.GetAbsoluteFilePath(TestData.GetTempPath(), Path.GetRandomFileName()) + ".py";
} while (File.Exists(filename));
}
var cancel = CancellationTokens.After60s;
using (var mre = new ManualResetEventSlim()) {
view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "",
v => {
v.TextView.TextBuffer.Properties[BufferParser.ParseImmediately] = true;
v.TextView.TextBuffer.Properties[IntellisenseController.SuppressErrorLists] = IntellisenseController.SuppressErrorLists;
v.TextView.TextBuffer.Properties[VsProjectAnalyzer._testAnalyzer] = analyzer;
v.TextView.TextBuffer.Properties[VsProjectAnalyzer._testFilename] = filename;
},
filename);
var entry = analyzer.GetAnalysisEntryFromPath(filename);
while (entry == null && !cancel.IsCancellationRequested)
{
Thread.Sleep(50);
entry = analyzer.GetAnalysisEntryFromPath(filename);
}
if (!string.IsNullOrEmpty(content) && !cancel.IsCancellationRequested && !entry.IsAnalyzed)
{
EventHandler evt = (s, e) => mre.SetIfNotDisposed();
try {
entry.AnalysisComplete += evt;
while (!mre.Wait(50, cancel) && !vs.HasPendingException && !entry.IsAnalyzed)
{
if (!analyzer.IsAnalyzing && !entry.IsAnalyzed)
{
var bp = entry.TryGetBufferParser();
Assert.IsNotNull(bp, "No buffer parser was ever created");
var bi = PythonTextBufferInfo.TryGetForBuffer(view.TextView.TextBuffer);
Assert.IsNotNull(bi, "No BufferInfo was ever created");
bi.LastSentSnapshot = null;
bp.EnsureCodeSyncedAsync(view.TextView.TextBuffer).WaitAndUnwrapExceptions();
}
}
} catch (OperationCanceledException) {
} finally {
entry.AnalysisComplete -= evt;
}
}
if (cancel.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 FallbackBuiltinPythonType(PythonLanguageVersion version, BuiltinTypeId typeId) {
DeclaringModule = version.Is3x() ? FallbackBuiltinModule.Instance3x : FallbackBuiltinModule.Instance2x;
Name = SharedDatabaseState.GetBuiltinTypeName(typeId, version.ToVersion());
TypeId = typeId;
}
private static InterpreterConfiguration GetAnacondaVersion(PythonLanguageVersion version, InterpreterArchitecture arch)
{
return(PythonInstallPathResolver.Instance.GetPythonConfiguration("Global|ContinuumAnalytics|", arch, version.ToVersion()));
}
public PythonAnalyzer CreateAnalyzer(PythonLanguageVersion version = PythonLanguageVersion.V27, string[] analysisDirs = null) {
// Explicitly provide the builtins name, since we aren't recreating
// the interpreter for each version like we should be.
var fact = InterpreterFactory;
var interp = Interpreter;
var builtinsName = "__builtin__";
if (version != fact.GetLanguageVersion()) {
fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
interp = fact.CreateInterpreter();
builtinsName = null;
}
var state = PythonAnalyzer.CreateSynchronously(fact, interp, builtinsName);
if (ShouldUseUnicodeLiterals(version)) {
var types = (KnownTypes)state.Types;
types._types[(int)BuiltinTypeId.Str] = state.Types[BuiltinTypeId.Unicode];
types._types[(int)BuiltinTypeId.StrIterator] = state.Types[BuiltinTypeId.UnicodeIterator];
types._classInfos[(int)BuiltinTypeId.Str] = state.ClassInfos[BuiltinTypeId.Unicode];
types._classInfos[(int)BuiltinTypeId.StrIterator] = state.ClassInfos[BuiltinTypeId.UnicodeIterator];
}
state.Limits = GetLimits();
if (analysisDirs != null) {
foreach (var dir in analysisDirs) {
state.AddAnalysisDirectory(dir);
}
}
return state;
}
internal PythonAnalyzer AnalyzeDir(string dir, PythonLanguageVersion version = PythonLanguageVersion.V27, IEnumerable <string> excludeDirectories = null, CancellationToken?cancel = null)
{
List <string> files = new List <string>();
try {
ISet <string> excluded = null;
if (excludeDirectories != null)
{
excluded = new HashSet <string>(excludeDirectories, StringComparer.InvariantCultureIgnoreCase);
}
CollectFiles(dir, files, excluded);
} catch (DirectoryNotFoundException) {
return(null);
}
List <FileStreamReader> sourceUnits = new List <FileStreamReader>();
foreach (string file in files)
{
sourceUnits.Add(
new FileStreamReader(file)
);
}
Stopwatch sw = new Stopwatch();
sw.Start();
long start0 = sw.ElapsedMilliseconds;
// Explicitly specify the builtins name because we are using a 2.7
// interpreter for all versions.
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var projectState = new PythonAnalyzer(fact, fact.CreateInterpreter(), "__builtin__");
projectState.ReloadModulesAsync().WaitAndUnwrapExceptions();
projectState.Limits = AnalysisLimits.GetStandardLibraryLimits();
var modules = new List <IPythonProjectEntry>();
foreach (var sourceUnit in sourceUnits)
{
try {
modules.Add(projectState.AddModule(
ModulePath.FromFullPath(sourceUnit.Path).ModuleName,
sourceUnit.Path,
null
));
} catch (ArgumentException) {
// Invalid module name, so skip the module
}
}
long start1 = sw.ElapsedMilliseconds;
Trace.TraceInformation("AddSourceUnit: {0} ms", start1 - start0);
var nodes = new List <Microsoft.PythonTools.Parsing.Ast.PythonAst>();
for (int i = 0; i < modules.Count; i++)
{
PythonAst ast = null;
try {
var sourceUnit = sourceUnits[i];
ast = Parser.CreateParser(sourceUnit, version).ParseFile();
} catch (Exception) {
}
nodes.Add(ast);
}
long start2 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Parse: {0} ms", start2 - start1);
for (int i = 0; i < modules.Count; i++)
{
var ast = nodes[i];
if (ast != null)
{
modules[i].UpdateTree(ast, null);
}
}
long start3 = sw.ElapsedMilliseconds;
for (int i = 0; i < modules.Count; i++)
{
Trace.TraceInformation("Analyzing {1}: {0} ms", sw.ElapsedMilliseconds - start3, sourceUnits[i].Path);
var ast = nodes[i];
if (ast != null)
{
modules[i].Analyze(cancel ?? CancellationToken.None, true);
}
}
if (modules.Count > 0)
{
Trace.TraceInformation("Analyzing queue");
modules[0].AnalysisGroup.AnalyzeQueuedEntries(cancel ?? CancellationToken.None);
}
long start4 = sw.ElapsedMilliseconds;
Trace.TraceInformation("Analyze: {0} ms", start4 - start3);
return(projectState);
}
public MockCompletionDB(string path, PythonLanguageVersion version) {
DBPath = path;
LanguageVersion = version;
_factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion(), null, DBPath);
Directory.CreateDirectory(DBPath);
}
public MockCompletionDB(string path, PythonLanguageVersion version)
{
DBPath = path;
LanguageVersion = version;
_factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion(), null, DBPath);
Directory.CreateDirectory(DBPath);
}
private SaveLoadResult SaveLoad(PythonLanguageVersion version, params AnalysisModule[] modules)
{
IPythonProjectEntry[] entries = new IPythonProjectEntry[modules.Length];
var fact = InterpreterFactory;
var interp = Interpreter;
if (version != fact.GetLanguageVersion()) {
fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
interp = fact.CreateInterpreter();
}
var codeFolder = TestData.GetTempPath(randomSubPath: true);
var dbFolder = Path.Combine(codeFolder, "DB");
Directory.CreateDirectory(codeFolder);
Directory.CreateDirectory(dbFolder);
var state = PythonAnalyzer.CreateSynchronously(fact, interp, SharedDatabaseState.BuiltinName2x);
for (int i = 0; i < modules.Length; i++) {
var fullname = Path.Combine(codeFolder, modules[i].Filename);
File.WriteAllText(fullname, modules[i].Code);
entries[i] = state.AddModule(modules[i].ModuleName, fullname);
Prepare(entries[i], new StringReader(modules[i].Code), version);
}
for (int i = 0; i < modules.Length; i++) {
entries[i].Analyze(CancellationToken.None, false);
}
new SaveAnalysis().Save(state, dbFolder);
File.Copy(
Path.Combine(PythonTypeDatabase.BaselineDatabasePath, "__builtin__.idb"),
Path.Combine(dbFolder, "__builtin__.idb"),
true
);
var loadFactory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(
version.ToVersion(),
null,
dbFolder
);
return new SaveLoadResult(PythonAnalyzer.CreateSynchronously(loadFactory), codeFolder);
}
public PythonAnalysis ProcessText(
string text,
PythonLanguageVersion version = PythonLanguageVersion.None,
bool allowParseErrors = false
) {
// TODO: Analyze against multiple versions when the version is None
if (version == PythonLanguageVersion.None) {
return ProcessTextV2(text, allowParseErrors);
}
var analysis = CreateAnalyzer(InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()), allowParseErrors);
analysis.AddModule("test-module", text);
analysis.WaitForAnalysis();
return analysis;
}
private IEnumerable<Task> StartCrossThreadAnalysisCalls(
CancellationToken cancel,
PythonLanguageVersion version
) {
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var state = PythonAnalyzer.CreateSynchronously(fact);
const string testCode = @"from mod{0:000} import test_func as other_test_func, MyClass as other_mc
c = None
def test_func(a, b={1}()):
'''My test function'''
globals c
a = b
a = {1}(a)
b = other_test_func(a)
c = other_mc.fn(b)
return b
class MyClass:
fn = test_func
my_test_func = test_func
my_test_func = other_test_func
my_test_func('abc')
mc = MyClass()
mc.fn([])
";
var entries = Enumerable.Range(0, 100)
.Select(i => {
var entry = state.AddModule(string.Format("mod{0:000}", i), string.Format("mod{0:000}.py", i));
entry.ParseFormat(PythonLanguageVersion.V34, testCode, i + 1, PythonTypes[i % PythonTypes.Count]);
return entry;
})
.ToList();
// One analysis before we start
foreach (var e in entries) {
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
// Repeatedly re-analyse the code
yield return Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested) {
var shufEntries = entries
.Select(e => Tuple.Create(rnd.Next(), e))
.OrderBy(t => t.Item1)
.Take(entries.Count / 2)
.Select(t => t.Item2)
.ToList();
foreach (var e in shufEntries) {
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
Console.WriteLine("Analysis complete");
Thread.Sleep(1000);
}
}, cancel);
// Repeatedly re-parse the code
yield return Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested) {
var shufEntries = entries
.Select((e, i) => Tuple.Create(rnd.Next(), e, i))
.OrderBy(t => t.Item1)
.Take(entries.Count / 4)
.ToList();
foreach (var t in shufEntries) {
var i = t.Item3;
t.Item2.ParseFormat(PythonLanguageVersion.V34, testCode, i + 1, PythonTypes[i % PythonTypes.Count]);
}
Thread.Sleep(1000);
}
}, cancel);
// Repeatedly request signatures
yield return Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested) {
var sigs = entry.Analysis.GetSignaturesByIndex("my_test_func", 0).ToList();
if (sigs.Any()) {
AssertUtil.ContainsExactly(
sigs.Select(s => s.Name),
"test_func"
);
foreach (var s in sigs) {
AssertUtil.ContainsExactly(s.Parameters.Select(p => p.Name), "a", "b");
}
}
}
}, cancel);
// Repeated request variables and descriptions
yield return Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested) {
var descriptions = entry.Analysis.GetDescriptionsByIndex("my_test_func", 0).ToList();
descriptions = entry.Analysis.GetDescriptionsByIndex("c", 0).ToList();
}
}, cancel);
// Repeated request members and documentation
yield return Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested) {
var descriptions = entry.Analysis.GetCompletionDocumentationByIndex("mc", "fn", 0).ToList();
}
}, cancel);
}
private IEnumerable <Task> StartCrossThreadAnalysisCalls(
CancellationToken cancel,
PythonLanguageVersion version
)
{
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var state = PythonAnalyzer.CreateSynchronously(fact);
const string testCode = @"from mod{0:000} import test_func as other_test_func, MyClass as other_mc
c = None
def test_func(a, b={1}()):
'''My test function'''
globals c
a = b
a = {1}(a)
b = other_test_func(a)
c = other_mc.fn(b)
return b
class MyClass:
fn = test_func
my_test_func = test_func
my_test_func = other_test_func
my_test_func('abc')
mc = MyClass()
mc.fn([])
";
var entries = Enumerable.Range(0, 100)
.Select(i => {
var entry = state.AddModule(string.Format("mod{0:000}", i), string.Format("mod{0:000}.py", i));
entry.ParseFormat(PythonLanguageVersion.V34, testCode, i + 1, PythonTypes[i % PythonTypes.Count]);
return(entry);
})
.ToList();
// One analysis before we start
foreach (var e in entries)
{
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
// Repeatedly re-analyse the code
yield return(Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested)
{
var shufEntries = entries
.Select(e => Tuple.Create(rnd.Next(), e))
.OrderBy(t => t.Item1)
.Take(entries.Count / 2)
.Select(t => t.Item2)
.ToList();
foreach (var e in shufEntries)
{
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
Console.WriteLine("Analysis complete");
Thread.Sleep(1000);
}
}, cancel));
// Repeatedly re-parse the code
yield return(Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested)
{
var shufEntries = entries
.Select((e, i) => Tuple.Create(rnd.Next(), e, i))
.OrderBy(t => t.Item1)
.Take(entries.Count / 4)
.ToList();
foreach (var t in shufEntries)
{
var i = t.Item3;
t.Item2.ParseFormat(PythonLanguageVersion.V34, testCode, i + 1, PythonTypes[i % PythonTypes.Count]);
}
Thread.Sleep(1000);
}
}, cancel));
// Repeatedly request signatures
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var sigs = entry.Analysis.GetSignaturesByIndex("my_test_func", 0).ToList();
if (sigs.Any())
{
AssertUtil.ContainsExactly(
sigs.Select(s => s.Name),
"test_func"
);
foreach (var s in sigs)
{
AssertUtil.ContainsExactly(s.Parameters.Select(p => p.Name), "a", "b");
}
}
}
}, cancel));
// Repeated request variables and descriptions
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var descriptions = entry.Analysis.GetDescriptionsByIndex("my_test_func", 0).ToList();
descriptions = entry.Analysis.GetDescriptionsByIndex("c", 0).ToList();
}
}, cancel));
// Repeated request members and documentation
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var descriptions = entry.Analysis.GetCompletionDocumentationByIndex("mc", "fn", 0).ToList();
}
}, cancel));
}
