public DerivedInterpreterFactory( PythonInterpreterFactoryWithDatabase baseFactory, InterpreterFactoryCreationOptions options ) : base( options.Id, options.Description, new InterpreterConfiguration( options.PrefixPath, options.InterpreterPath, options.WindowInterpreterPath, options.LibraryPath, options.PathEnvironmentVariableName, options.Architecture, options.LanguageVersion, InterpreterUIMode.CannotBeDefault | InterpreterUIMode.CannotBeConfigured ), options.WatchLibraryForNewModules ) { if (baseFactory.Configuration.Version != options.LanguageVersion) { throw new ArgumentException("Language versions do not match", "options"); } _base = baseFactory; _base.IsCurrentChanged += Base_IsCurrentChanged; _base.NewDatabaseAvailable += Base_NewDatabaseAvailable; _description = options.Description; if (Volatile.Read(ref _deferRefreshIsCurrent)) { // This rare race condition is due to a design flaw that is in // shipped public API and cannot be fixed without breaking // compatibility with 3rd parties. RefreshIsCurrent(); } }
public PythonTypeDatabase( PythonInterpreterFactoryWithDatabase factory, IEnumerable <string> databaseDirectories = null, PythonTypeDatabase innerDatabase = null ) { if (innerDatabase != null && factory.Configuration.Version != innerDatabase.LanguageVersion) { throw new InvalidOperationException("Language versions do not match"); } _factory = factory; if (innerDatabase != null) { _sharedState = new SharedDatabaseState(innerDatabase._sharedState); } else { _sharedState = new SharedDatabaseState(_factory.Configuration.Version); } if (databaseDirectories != null) { foreach (var d in databaseDirectories) { LoadDatabase(d); } } _sharedState.ListenForCorruptDatabase(this); }
public DerivedInterpreterFactory(PythonInterpreterFactoryWithDatabase baseFactory, InterpreterFactoryCreationOptions options) : base(options.Id, options.Description, new InterpreterConfiguration(options.PrefixPath, options.InterpreterPath, options.WindowInterpreterPath, options.LibraryPath, options.PathEnvironmentVariableName, options.Architecture, options.LanguageVersion), options.WatchLibraryForNewModules) { if (baseFactory.Configuration.Version != options.LanguageVersion) { throw new ArgumentException("Language versions do not match", "options"); } _base = baseFactory; _base.IsCurrentChanged += Base_IsCurrentChanged; _base.NewDatabaseAvailable += Base_NewDatabaseAvailable; _description = options.Description; if (Volatile.Read(ref _deferRefreshIsCurrent)) { // This rare race condition is due to a design flaw that is in // shipped public API and cannot be fixed without breaking // compatibility with 3rd parties. RefreshIsCurrent(); } }
public IronPythonInterpreter(PythonInterpreterFactoryWithDatabase factory) { #if DEBUG _id = Interlocked.Increment(ref _interpreterCount); Debug.WriteLine(String.Format("IronPython Interpreter Created {0}", _id)); Debug.WriteLine(new StackTrace(true).ToString()); #endif AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver.Instance.CurrentDomain_AssemblyResolve; InitializeRemoteDomain(); try { LoadAssemblies(); } catch { // IronPython not installed in the GAC... } var mod = Remote.ImportBuiltinModule("__builtin__"); var newMod = new IronPythonBuiltinModule(this, mod, "__builtin__"); _modules[newMod.Name] = newMod; _factory = factory; _typeDb = _factory.GetCurrentDatabase().CloneWithNewBuiltins(newMod); _factory.NewDatabaseAvailable += OnNewDatabaseAvailable; LoadModules(); }
public bool IsConfigurable(IPythonInterpreterFactory factory) { PythonInterpreterFactoryWithDatabase fact = factory as PythonInterpreterFactoryWithDatabase; if (fact == null) { return(false); } return(_interpreters.ContainsValue(fact)); }
private PythonTypeDatabase( PythonInterpreterFactoryWithDatabase factory, string databaseDirectory, bool isDefaultDatabase ) { _factory = factory; _sharedState = new SharedDatabaseState( factory.Configuration.Version, databaseDirectory, defaultDatabase: isDefaultDatabase ); }
private PythonTypeDatabase( PythonInterpreterFactoryWithDatabase factory, string databaseDirectory, bool isDefaultDatabase ) { _factory = factory; _sharedState = new SharedDatabaseState( factory.Configuration.Version, databaseDirectory, defaultDatabase: isDefaultDatabase ); }
public DerivedInterpreterFactory( PythonInterpreterFactoryWithDatabase baseFactory, InterpreterConfiguration config, InterpreterFactoryCreationOptions options ) : base(config, options.WatchLibraryForNewModules) { _base = baseFactory; _base.IsCurrentChanged += Base_IsCurrentChanged; _base.NewDatabaseAvailable += Base_NewDatabaseAvailable; if (Volatile.Read(ref _deferRefreshIsCurrent)) { // This rare race condition is due to a design flaw that is in // shipped public API and cannot be fixed without breaking // compatibility with 3rd parties. RefreshIsCurrent(); } }
public DerivedInterpreterFactory( PythonInterpreterFactoryWithDatabase baseFactory, InterpreterConfiguration config, InterpreterFactoryCreationOptions options ) : base(config, options.WatchLibraryForNewModules) { _base = baseFactory; _base.IsCurrentChanged += Base_IsCurrentChanged; _base.NewDatabaseAvailable += Base_NewDatabaseAvailable; if (Volatile.Read(ref _deferRefreshIsCurrent)) { // This rare race condition is due to a design flaw that is in // shipped public API and cannot be fixed without breaking // compatibility with 3rd parties. RefreshIsCurrent(); } }
public PythonTypeDatabase( PythonInterpreterFactoryWithDatabase factory, IEnumerable<string> databaseDirectories = null, PythonTypeDatabase innerDatabase = null ) { if (innerDatabase != null && factory.Configuration.Version != innerDatabase.LanguageVersion) { throw new InvalidOperationException("Language versions do not match"); } _factory = factory; if (innerDatabase != null) { _sharedState = new SharedDatabaseState(innerDatabase._sharedState); } else { _sharedState = new SharedDatabaseState(_factory.Configuration.Version); } if (databaseDirectories != null) { foreach (var d in databaseDirectories) { LoadDatabase(d); } } _sharedState.ListenForCorruptDatabase(this); }
public override IPythonInterpreter MakeInterpreter(PythonInterpreterFactoryWithDatabase factory) { return new PythonUwpInterpreter(factory); }
public override IPythonInterpreter MakeInterpreter(PythonInterpreterFactoryWithDatabase factory) { return(_base.MakeInterpreter(factory)); }
public static PythonTypeDatabase CreateDefaultTypeDatabase(PythonInterpreterFactoryWithDatabase factory) { return new PythonTypeDatabase(factory, BaselineDatabasePath, isDefaultDatabase: true); }
public PythonTypeDatabase CloneWithNewFactory(PythonInterpreterFactoryWithDatabase newFactory) { return(new PythonTypeDatabase(newFactory, null, this)); }
/// <summary> /// Returns a new interpreter created with the specified factory. /// </summary> /// <remarks> /// This is intended for use by derived classes only. To get an /// interpreter instance, use <see cref="CreateInterpreter"/>. /// </remarks> public virtual IPythonInterpreter MakeInterpreter(PythonInterpreterFactoryWithDatabase factory) { return(new CPythonInterpreter(factory)); }
public MockCompletionDB(string path, PythonLanguageVersion version) { DBPath = path; LanguageVersion = version; _factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion(), null, DBPath); Directory.CreateDirectory(DBPath); }
/// <summary> /// Call to find interpreters in the associated project. Separated from /// the constructor to allow exceptions to be handled without causing /// the project node to be invalid. /// </summary> /// <exception cref="InvalidDataException"> /// One or more interpreters failed to load. The error message should be /// presented to the user, but can otherwise be ignored. /// </exception> public void DiscoverInterpreters() { // <Interpreter Include="InterpreterDirectory"> // <Id>guid</Id> // <BaseInterpreter>guid</BaseInterpreter> // <Version>...</Version> // <InterpreterPath>...</InterpreterPath> // <WindowsInterpreterPath>...</WindowsInterpreterPath> // <LibraryPath>...</LibraryPath> // <PathEnvironmentVariable>...</PathEnvironmentVariable> // <Description>...</Description> // </Interpreter> var errors = new StringBuilder(); errors.AppendLine("Some project interpreters failed to load:"); bool anyChange = false, anyError = false; var projectHome = CommonUtils.GetAbsoluteDirectoryPath(_project.DirectoryPath, _project.GetPropertyValue("ProjectHome")); var factories = new Dictionary <IPythonInterpreterFactory, FactoryInfo>(); foreach (var item in _project.GetItems(InterpreterItem)) { IPythonInterpreterFactory fact; Guid id, baseId; // Errors in these options are fatal, so we set anyError and // continue with the next entry. var dir = item.EvaluatedInclude; if (!CommonUtils.IsValidPath(dir)) { errors.AppendLine(string.Format("Interpreter has invalid path: {0}", dir ?? "(null)")); anyError = true; continue; } dir = CommonUtils.GetAbsoluteDirectoryPath(projectHome, dir); var value = item.GetMetadataValue(IdKey); if (string.IsNullOrEmpty(value) || !Guid.TryParse(value, out id)) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, IdKey, value)); anyError = true; continue; } if (factories.Keys.Any(f => f.Id == id)) { errors.AppendLine(string.Format("Interpreter {0} has a non-unique id: {1}", dir, id)); continue; } var verStr = item.GetMetadataValue(VersionKey); Version ver; if (string.IsNullOrEmpty(verStr) || !Version.TryParse(verStr, out ver)) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, VersionKey, verStr)); anyError = true; continue; } // The rest of the options are non-fatal. We create an instance // of NotFoundError with an amended description, which will // allow the user to remove the entry from the project file // later. bool hasError = false; var description = item.GetMetadataValue(DescriptionKey); if (string.IsNullOrEmpty(description)) { description = CommonUtils.CreateFriendlyDirectoryPath(projectHome, dir); } value = item.GetMetadataValue(BaseInterpreterKey); PythonInterpreterFactoryWithDatabase baseInterp = null; if (!string.IsNullOrEmpty(value) && Guid.TryParse(value, out baseId)) { // It's a valid GUID, so find a suitable base. If we // don't find one now, we'll try and figure it out from // the pyvenv.cfg/orig-prefix.txt files later. // Using an empty GUID will always go straight to the // later lookup. if (baseId != Guid.Empty) { baseInterp = _service.FindInterpreter(baseId, ver) as PythonInterpreterFactoryWithDatabase; } } var path = item.GetMetadataValue(InterpreterPathKey); if (!CommonUtils.IsValidPath(path)) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, InterpreterPathKey, path)); hasError = true; } else if (!hasError) { path = CommonUtils.GetAbsoluteFilePath(dir, path); } var winPath = item.GetMetadataValue(WindowsPathKey); if (!CommonUtils.IsValidPath(winPath)) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, WindowsPathKey, winPath)); hasError = true; } else if (!hasError) { winPath = CommonUtils.GetAbsoluteFilePath(dir, winPath); } var libPath = item.GetMetadataValue(LibraryPathKey); if (string.IsNullOrEmpty(libPath)) { libPath = "lib"; } if (!CommonUtils.IsValidPath(libPath)) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, LibraryPathKey, libPath)); hasError = true; } else if (!hasError) { libPath = CommonUtils.GetAbsoluteDirectoryPath(dir, libPath); } var pathVar = item.GetMetadataValue(PathEnvVarKey); if (string.IsNullOrEmpty(pathVar)) { if (baseInterp != null) { pathVar = baseInterp.Configuration.PathEnvironmentVariable; } else { pathVar = "PYTHONPATH"; } } string arch = null; if (baseInterp == null) { arch = item.GetMetadataValue(ArchitectureKey); if (string.IsNullOrEmpty(arch)) { arch = "x86"; } } if (baseInterp == null && !hasError) { // Only thing missing is the base interpreter, so let's try // to find it using paths baseInterp = DerivedInterpreterFactory.FindBaseInterpreterFromVirtualEnv(dir, libPath, _service) as PythonInterpreterFactoryWithDatabase; if (baseInterp == null) { errors.AppendLine(string.Format("Interpreter {0} has invalid value for '{1}': {2}", dir, BaseInterpreterKey, value ?? "(null)")); hasError = true; } } if (hasError) { fact = new NotFoundInterpreterFactory( id, ver, string.Format("{0} (unavailable)", description), Directory.Exists(dir) ? dir : null ); } else if (baseInterp != null) { MigrateOldDerivedInterpreterFactoryDatabase(id, baseInterp.Configuration.Version, dir); fact = new DerivedInterpreterFactory( baseInterp, new InterpreterFactoryCreationOptions { LanguageVersion = baseInterp.Configuration.Version, Id = id, Description = description, InterpreterPath = path, WindowInterpreterPath = winPath, LibraryPath = libPath, PrefixPath = dir, PathEnvironmentVariableName = pathVar, Architecture = baseInterp.Configuration.Architecture, WatchLibraryForNewModules = true } ); } else { fact = InterpreterFactoryCreator.CreateInterpreterFactory(new InterpreterFactoryCreationOptions { LanguageVersion = ver, Id = id, Description = description, InterpreterPath = path, WindowInterpreterPath = winPath, LibraryPath = libPath, PrefixPath = dir, PathEnvironmentVariableName = pathVar, ArchitectureString = arch, WatchLibraryForNewModules = true }); } var existing = FindInterpreter(id, ver); if (existing != null && existing.IsEqual(fact)) { factories[existing] = new FactoryInfo(item, factories[existing].Owned); var disposable = fact as IDisposable; if (disposable != null) { disposable.Dispose(); } } else { _rootPaths[id] = dir; factories[fact] = new FactoryInfo(item, true); anyChange = true; } } // <InterpreterReference Include="{guid};{version}" /> foreach (var item in _project.GetItems(InterpreterReferenceItem)) { var match = InterpreterReferencePath.Match(item.EvaluatedInclude); if (match == null || !match.Success || !match.Groups.Cast <Group>().All(g => g.Success)) { errors.AppendLine(string.Format("Interpreter reference has invalid path: {0}", item.EvaluatedInclude)); anyError = true; continue; } Guid id; var value = match.Groups["id"]; if (string.IsNullOrEmpty(value.Value) || !Guid.TryParse(value.Value, out id)) { errors.AppendLine(string.Format("Interpreter reference has invalid id: {0}", value.Value ?? "(null)")); anyError = true; continue; } Version ver; value = match.Groups["version"]; if (string.IsNullOrEmpty(value.Value) || !Version.TryParse(value.Value, out ver)) { errors.AppendLine(string.Format("Interpreter reference has invalid version: {0}", value.Value ?? "(null)")); anyError = true; continue; } bool owned = false; var fact = _service.FindInterpreter(id, ver); if (fact == null) { owned = true; fact = new NotFoundInterpreterFactory(id, ver); } var existing = FindInterpreter(id, ver); if (existing != null) { factories[existing] = new FactoryInfo(item, factories[existing].Owned); if (owned) { ((PythonInterpreterFactoryWithDatabase)fact).Dispose(); } } else { factories[fact] = new FactoryInfo(item, owned); anyChange = true; } } if (anyChange || _factories == null || factories.Count != _factories.Count) { // Lock here mainly to ensure that any searches complete before // we trigger the changed event. lock (_factoriesLock) { _factories = factories; } OnInterpreterFactoriesChanged(); UpdateActiveInterpreter(); } if (anyError) { throw new InvalidDataException(errors.ToString()); } }
public static PythonTypeDatabase CreateDefaultTypeDatabase(PythonInterpreterFactoryWithDatabase factory) { return(new PythonTypeDatabase(factory, BaselineDatabasePath, isDefaultDatabase: true)); }
/// <summary> /// Returns a new interpreter created with the specified factory. /// </summary> /// <remarks> /// This is intended for use by derived classes only. To get an /// interpreter instance, use <see cref="CreateInterpreter"/>. /// </remarks> public virtual IPythonInterpreter MakeInterpreter(PythonInterpreterFactoryWithDatabase factory) { return new CPythonInterpreter(factory); }
private CanopyInterpreterFactory( Guid id, string description, PythonInterpreterFactoryWithDatabase baseFactory, InterpreterConfiguration config ) : base(id, description, config, true) { if (baseFactory == null) { throw new ArgumentNullException("baseFactory"); } _base = baseFactory; _base.IsCurrentChanged += OnIsCurrentChanged; _base.NewDatabaseAvailable += OnNewDatabaseAvailable; }
public void Dispose() { _typeDb = null; var factory = _factory; _factory = null; if (factory != null) { factory.NewDatabaseAvailable -= OnNewDatabaseAvailable; } }
public PythonUwpInterpreter(PythonInterpreterFactoryWithDatabase factory) { _langVersion = factory.Configuration.Version; _factory = factory; _typeDb = _factory.GetCurrentDatabase(); _factory.NewDatabaseAvailable += OnNewDatabaseAvailable; }
public PythonTypeDatabase CloneWithNewFactory(PythonInterpreterFactoryWithDatabase newFactory) { return new PythonTypeDatabase(newFactory, null, this); }
/// <summary> /// Creates the Canopy User interpreter. This handles layering of the /// User database on top of the App database, and ensures that refreshes /// work correctly. /// /// Because it is exposed as its own factory type, it can also be used /// as a base interpreter for DerivedInterpreterFactory (virtual /// environments). /// </summary> public static CanopyInterpreterFactory Create( PythonInterpreterFactoryWithDatabase baseFactory, string userPath, string canopyVersion ) { var interpPath = FindFile(userPath, CanopyInterpreterFactoryConstants.ConsoleExecutable); var winInterpPath = FindFile(userPath, CanopyInterpreterFactoryConstants.WindowsExecutable); var libPath = Path.Combine(userPath, CanopyInterpreterFactoryConstants.LibrarySubPath); if (!File.Exists(interpPath)) { throw new FileNotFoundException(interpPath); } if (!File.Exists(winInterpPath)) { throw new FileNotFoundException(winInterpPath); } if (!Directory.Exists(libPath)) { throw new DirectoryNotFoundException(libPath); } var id = (baseFactory.Configuration.Architecture == ProcessorArchitecture.Amd64) ? CanopyInterpreterFactoryConstants.UserGuid64 : CanopyInterpreterFactoryConstants.UserGuid32; // Make the description string look like "Canopy 1.1.0.46 (2.7 32-bit)" var description = "Canopy "; if (!string.IsNullOrEmpty(canopyVersion)) { description += " " + canopyVersion; } description += string.Format(" ({0} ", baseFactory.Configuration.Version); if (baseFactory.Configuration.Architecture == ProcessorArchitecture.Amd64) { description += " 64-bit)"; } else { description += " 32-bit)"; } var config = new InterpreterConfiguration( userPath, interpPath, winInterpPath, libPath, CanopyInterpreterFactoryConstants.PathEnvironmentVariableName, baseFactory.Configuration.Architecture, baseFactory.Configuration.Version ); return new CanopyInterpreterFactory(id, description, baseFactory, config); }