private bool TryCreateStubModule(string name, out IPythonModule module)
{
module = null;
var moduleImport = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (moduleImport != null)
{
if (moduleImport.IsCompiled)
{
Log?.Log(TraceEventType.Warning, "Unsupported native module in stubs", moduleImport.FullName, moduleImport.ModulePath);
return(false);
}
module = new StubPythonModule(moduleImport.FullName, moduleImport.ModulePath, true, Services);
return(true);
}
var i = name.IndexOf('.');
if (i == 0)
{
Debug.Fail("Invalid module name");
return(false);
}
var stubPath = CurrentPathResolver.GetPossibleModuleStubPaths(name).FirstOrDefault(p => FileSystem.FileExists(p));
if (stubPath != null)
{
module = new StubPythonModule(name, stubPath, true, Services);
return(true);
}
return(false);
}
protected override IPythonModule CreateModule(string name)
{
var moduleImport = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (moduleImport != default)
{
if (moduleImport.IsCompiled)
{
Log?.Log(TraceEventType.Warning, "Unsupported native module in stubs", moduleImport.FullName, moduleImport.ModulePath);
return(null);
}
return(new StubPythonModule(moduleImport.FullName, moduleImport.ModulePath, true, Services));
}
var i = name.IndexOf('.');
if (i == 0)
{
Debug.Fail("Invalid module name");
return(null);
}
var stubPath = CurrentPathResolver.GetPossibleModuleStubPaths(name).FirstOrDefault(p => FileSystem.FileExists(p));
return(stubPath != null ? new StubPythonModule(name, stubPath, true, Services) : null);
}
protected override IPythonModule CreateModule(string name)
{
var mp = FindModuleInSearchPath(_typeStubPaths, null, name);
if (mp != null)
{
if (mp.Value.IsCompiled)
{
_log?.Log(TraceEventType.Warning, "Unsupported native module in stubs", mp.Value.FullName, mp.Value.SourceFile);
return(null);
}
return(new StubPythonModule(mp.Value.FullName, mp.Value.SourceFile, true, _services));
}
var i = name.IndexOf('.');
if (i == 0)
{
Debug.Fail("Invalid module name");
return(null);
}
var stubPath = CurrentPathResolver.GetPossibleModuleStubPaths(name).FirstOrDefault(p => _fs.FileExists(p));
return(stubPath != null ? new StubPythonModule(name, stubPath, true, _services) : null);
}
private async Task <IPythonModule> ImportFromTypeStubsAsync(string name, CancellationToken cancellationToken = default)
{
var mp = FindModuleInSearchPath(_typeStubPaths, null, name);
if (mp != null)
{
if (mp.Value.IsCompiled)
{
_log?.Log(TraceEventType.Warning, "Unsupported native module in stubs", mp.Value.FullName, mp.Value.SourceFile);
return(null);
}
return(await CreateStubModuleAsync(mp.Value.FullName, mp.Value.SourceFile, cancellationToken));
}
var i = name.IndexOf('.');
if (i == 0)
{
Debug.Fail("Invalid module name");
return(null);
}
var stubPath = CurrentPathResolver.GetPossibleModuleStubPaths(name).FirstOrDefault(p => _fs.FileExists(p));
return(stubPath != null ? await CreateStubModuleAsync(name, stubPath, cancellationToken) : null);
}
/// <summary>
/// Provides ability to specialize module by replacing module import by
/// <see cref="IPythonModule"/> implementation in code. Real module
/// content is loaded and analyzed only for class/functions definitions
/// so the original documentation can be extracted.
/// </summary>
/// <param name="name">Module to specialize.</param>
/// <param name="specializationConstructor">Specialized module constructor.</param>
/// <returns>Original (library) module loaded as stub.</returns>
public IPythonModule SpecializeModule(string name, Func <string, IPythonModule> specializationConstructor)
{
var import = CurrentPathResolver.GetModuleImportFromModuleName(name);
var module = specializationConstructor(import?.ModulePath);
_specialized[name] = module;
return(module);
}
protected override IPythonModule CreateModule(string name)
{
var moduleImport = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (moduleImport == null)
{
_log?.Log(TraceEventType.Verbose, "Import not found: ", name);
return(null);
}
if (moduleImport.ModulePath != null)
{
var module = GetRdt().GetDocument(new Uri(moduleImport.ModulePath));
if (module != null)
{
GetRdt().LockDocument(module.Uri);
return(module);
}
}
// If there is a stub, make sure it is loaded and attached
// First check stub next to the module.
if (!TryCreateModuleStub(name, moduleImport.ModulePath, out var stub))
{
// If nothing found, try Typeshed.
stub = _interpreter.TypeshedResolution.GetOrLoadModule(moduleImport.IsBuiltin ? name : moduleImport.FullName);
}
// If stub is created and its path equals to module, return that stub as module
if (stub != null && stub.FilePath.PathEquals(moduleImport.ModulePath))
{
return(stub);
}
if (moduleImport.IsBuiltin)
{
_log?.Log(TraceEventType.Verbose, "Create built-in compiled (scraped) module: ", name, Configuration.InterpreterPath);
return(new CompiledBuiltinPythonModule(name, stub, _services));
}
if (moduleImport.IsCompiled)
{
_log?.Log(TraceEventType.Verbose, "Create compiled (scraped): ", moduleImport.FullName, moduleImport.ModulePath, moduleImport.RootPath);
return(new CompiledPythonModule(moduleImport.FullName, ModuleType.Compiled, moduleImport.ModulePath, stub, _services));
}
_log?.Log(TraceEventType.Verbose, "Import: ", moduleImport.FullName, moduleImport.ModulePath);
// Module inside workspace == user code.
var mco = new ModuleCreationOptions {
ModuleName = moduleImport.FullName,
ModuleType = moduleImport.IsLibrary ? ModuleType.Library : ModuleType.User,
FilePath = moduleImport.ModulePath,
Stub = stub
};
return(GetRdt().AddModule(mco));
}
/// <summary>
/// Provides ability to specialize module by replacing module import by
/// <see cref="IPythonModule"/> implementation in code. Real module
/// content is loaded and analyzed only for class/functions definitions
/// so the original documentation can be extracted.
/// </summary>
/// <param name="name">Module to specialize.</param>
/// <param name="specializationConstructor">Specialized module constructor.</param>
/// <param name="replaceExisting">Replace existing loaded module, if any.</param>
/// <returns>Specialized module.</returns>
public IPythonModule SpecializeModule(string name, Func <string, IPythonModule> specializationConstructor, bool replaceExisting = false)
{
var import = CurrentPathResolver.GetModuleImportFromModuleName(name);
var module = specializationConstructor(import?.ModulePath);
_specialized[name] = module;
if (replaceExisting)
{
Modules.TryRemove(name, out _);
}
return(module);
}
/// <summary>
/// Provides ability to specialize module by replacing module import by
/// <see cref="IPythonModule"/> implementation in code. Real module
/// content is loaded and analyzed only for class/functions definitions
/// so the original documentation can be extracted.
/// </summary>
/// <param name="name">Module to specialize.</param>
/// <param name="specializationConstructor">Specialized module constructor.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>Original (library) module loaded as stub.</returns>
public async Task <IPythonModule> SpecializeModuleAsync(string name, Func <string, IPythonModule> specializationConstructor, CancellationToken cancellationToken = default)
{
var import = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (!string.IsNullOrEmpty(import?.ModulePath))
{
var module = specializationConstructor(import.ModulePath);
_modules[name] = module;
await module.LoadAndAnalyzeAsync(cancellationToken);
return(module);
}
return(null);
}
private bool TryCreateModuleStub(string name, string modulePath, out IPythonModule module)
{
// First check stub next to the module.
if (!string.IsNullOrEmpty(modulePath))
{
var pyiPath = Path.ChangeExtension(modulePath, "pyi");
if (FileSystem.FileExists(pyiPath))
{
module = new StubPythonModule(name, pyiPath, false, Services);
return(true);
}
}
// Try location of stubs that are in a separate folder next to the package.
var stubPath = CurrentPathResolver.GetPossibleModuleStubPaths(name).FirstOrDefault(p => FileSystem.FileExists(p));
module = !string.IsNullOrEmpty(stubPath) ? new StubPythonModule(name, stubPath, false, Services) : null;
return(module != null);
}
private async Task <IPythonModule> ImportFromSearchPathsAsync(string name, CancellationToken cancellationToken)
{
var moduleImport = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (moduleImport == null)
{
_log?.Log(TraceEventType.Verbose, "Import not found: ", name);
return(null);
}
// If there is a stub, make sure it is loaded and attached
var stub = await ImportFromTypeStubsAsync(moduleImport.IsBuiltin?name : moduleImport.FullName, cancellationToken);
IPythonModule module;
if (moduleImport.IsBuiltin)
{
_log?.Log(TraceEventType.Verbose, "Import built-in compiled (scraped) module: ", name, Configuration.InterpreterPath);
module = new CompiledBuiltinPythonModule(name, stub, _services);
}
else if (moduleImport.IsCompiled)
{
_log?.Log(TraceEventType.Verbose, "Import compiled (scraped): ", moduleImport.FullName, moduleImport.ModulePath, moduleImport.RootPath);
module = new CompiledPythonModule(moduleImport.FullName, ModuleType.Compiled, moduleImport.ModulePath, stub, _services);
}
else
{
_log?.Log(TraceEventType.Verbose, "Import: ", moduleImport.FullName, moduleImport.ModulePath);
var rdt = _services.GetService <IRunningDocumentTable>();
// TODO: handle user code and library module separately.
var mco = new ModuleCreationOptions {
ModuleName = moduleImport.FullName,
ModuleType = ModuleType.Library,
FilePath = moduleImport.ModulePath,
Stub = stub,
LoadOptions = ModuleLoadOptions.Analyze
};
module = rdt.AddModule(mco);
}
await module.LoadAndAnalyzeAsync(cancellationToken).ConfigureAwait(false);
return(module);
}
protected override IPythonModule CreateModule(string name)
{
var moduleImport = CurrentPathResolver.GetModuleImportFromModuleName(name);
if (moduleImport == null)
{
Log?.Log(TraceEventType.Verbose, "Import not found: ", name);
return(null);
}
IPythonModule module;
if (moduleImport.ModulePath != null)
{
module = GetRdt().GetDocument(new Uri(moduleImport.ModulePath));
if (module != null)
{
GetRdt().LockDocument(module.Uri);
return(module);
}
}
var moduleType = moduleImport.IsBuiltin ? ModuleType.CompiledBuiltin
: moduleImport.IsCompiled ? ModuleType.Compiled
: moduleImport.IsLibrary ? ModuleType.Library
: ModuleType.User;
var dbs = GetDbService();
if (dbs != null)
{
var sw = Stopwatch.StartNew();
module = dbs.RestoreModule(name, moduleImport.ModulePath, moduleType);
sw.Stop();
if (module != null)
{
Log?.Log(TraceEventType.Verbose, $"Restored from database: {name} in {sw.ElapsedMilliseconds} ms.");
Interpreter.ModuleResolution.SpecializeModule(name, x => module, true);
return(module);
}
}
// If there is a stub, make sure it is loaded and attached
// First check stub next to the module.
if (TryCreateModuleStub(name, moduleImport.ModulePath, out var stub))
{
Analyzer.InvalidateAnalysis(stub);
}
else
{
// If nothing found, try Typeshed.
stub = Interpreter.TypeshedResolution.GetOrLoadModule(moduleImport.IsBuiltin ? name : moduleImport.FullName);
}
// If stub is created and its path equals to module, return that stub as module
if (stub != null && stub.FilePath.PathEquals(moduleImport.ModulePath))
{
return(stub);
}
if (moduleImport.IsBuiltin)
{
Log?.Log(TraceEventType.Verbose, "Create built-in compiled (scraped) module: ", name, Configuration.InterpreterPath);
return(new CompiledBuiltinPythonModule(name, stub, Services));
}
if (moduleImport.IsCompiled)
{
Log?.Log(TraceEventType.Verbose, "Create compiled (scraped): ", moduleImport.FullName, moduleImport.ModulePath, moduleImport.RootPath);
return(new CompiledPythonModule(moduleImport.FullName, ModuleType.Compiled, moduleImport.ModulePath, stub, false, Services));
}
Log?.Log(TraceEventType.Verbose, "Import: ", moduleImport.FullName, moduleImport.ModulePath);
// Module inside workspace == user code.
var mco = new ModuleCreationOptions {
ModuleName = moduleImport.FullName,
ModuleType = moduleType,
FilePath = moduleImport.ModulePath,
Stub = stub
};
return(GetRdt().AddModule(mco));
}
