/// <summary> /// Returns a list of profile data. The values are tuples of Profiler.Data objects /// /// All times are expressed in the same unit of measure as DateTime.Ticks /// </summary> public static PythonTuple GetProfilerData(CodeContext /*!*/ context, [DefaultParameterValue(false)] bool includeUnused) { return(new PythonTuple(Profiler.GetProfiler(PythonContext.GetContext(context)).GetProfile(includeUnused))); }
/// <summary> /// Resets all profiler counters back to zero /// </summary> public static void ClearProfilerData(CodeContext /*!*/ context) { Profiler.GetProfiler(PythonContext.GetContext(context)).Reset(); }
/// <summary> /// Interrogates the importing module for __name__ and __path__, which determine /// whether the imported module (whose name is 'name') is being imported as nested /// module (__path__ is present) or as sibling. /// /// For sibling import, the full name of the imported module is parent.sibling /// For nested import, the full name of the imported module is parent.module.nested /// where parent.module is the mod.__name__ /// </summary> /// <param name="context"></param> /// <param name="globals">the globals dictionary</param> /// <param name="name">Name of the module to be imported</param> /// <param name="full">Output - full name of the module being imported</param> /// <param name="path">Path to use to search for "full"</param> /// <param name="level">the import level for relaive imports</param> /// <param name="parentMod">the parent module</param> /// <param name="package">the global __package__ value</param> /// <returns></returns> private static bool TryGetNameAndPath(CodeContext /*!*/ context, object globals, string name, int level, string package, out string full, out List path, out PythonModule parentMod) { Debug.Assert(level != 0); // shouldn't be here for absolute imports // Unless we can find enough information to perform relative import, // we are going to import the module whose name we got full = name; path = null; parentMod = null; // We need to get __name__ to find the name of the imported module. // If absent, fall back to absolute import object attribute; PythonDictionary pyGlobals = globals as PythonDictionary; if (pyGlobals == null || !pyGlobals._storage.TryGetName(out attribute)) { return(false); } // And the __name__ needs to be string string modName = attribute as string; if (modName == null) { return(false); } string pn; if (package == null) { // If the module has __path__ (and __path__ is list), nested module is being imported // otherwise, importing sibling to the importing module if (pyGlobals._storage.TryGetPath(out attribute) && (path = attribute as List) != null) { // found __path__, importing nested module. The actual name of the nested module // is the name of the mod plus the name of the imported module if (level == -1) { // absolute import of some module full = modName + "." + name; object parentModule; if (PythonContext.GetContext(context).SystemStateModules.TryGetValue(modName, out parentModule)) { parentMod = parentModule as PythonModule; } } else if (String.IsNullOrEmpty(name)) { // relative import of ancestor full = (StringOps.rsplit(modName, ".", level - 1)[0] as string); } else { // relative import of some ancestors child string parentName = (StringOps.rsplit(modName, ".", level - 1)[0] as string); full = parentName + "." + name; object parentModule; if (PythonContext.GetContext(context).SystemStateModules.TryGetValue(parentName, out parentModule)) { parentMod = parentModule as PythonModule; } } return(true); } // importing sibling. The name of the imported module replaces // the last element in the importing module name int lastDot = modName.LastIndexOf('.'); if (lastDot == -1) { // name doesn't include dot, only absolute import possible if (level > 0) { throw PythonOps.ValueError("Attempted relative import in non-package"); } return(false); } // need to remove more than one name int tmpLevel = level; while (tmpLevel > 1 && lastDot != -1) { lastDot = modName.LastIndexOf('.', lastDot - 1); tmpLevel--; } if (lastDot == -1) { pn = modName; } else { pn = modName.Substring(0, lastDot); } } else { // __package__ doesn't include module name, so level is - 1. pn = GetParentPackageName(level - 1, package.Split('.')); } path = GetParentPathAndModule(context, pn, out parentMod); if (path != null) { if (String.IsNullOrEmpty(name)) { full = pn; } else { full = pn + "." + name; } return(true); } if (level > 0) { throw PythonOps.SystemError("Parent module '{0}' not loaded, cannot perform relative import", pn); } // not enough information - absolute import return(false); }
internal static object ReloadModule(CodeContext /*!*/ context, PythonModule /*!*/ module, PythonFile file) { PythonContext pc = PythonContext.GetContext(context); // We created the module and it only contains Python code. If the user changes // __file__ we'll reload from that file. string fileName = module.GetFile() as string; // built-in module: if (fileName == null) { ReloadBuiltinModule(context, module); return(module); } string name = module.GetName() as string; if (name != null) { List path = null; // find the parent module and get it's __path__ property int dotIndex = name.LastIndexOf('.'); if (dotIndex != -1) { PythonModule parentModule; path = GetParentPathAndModule(context, name.Substring(0, dotIndex), out parentModule); } object reloaded; if (TryLoadMetaPathModule(context, module.GetName() as string, path, out reloaded) && reloaded != null) { return(module); } List sysPath; if (PythonContext.GetContext(context).TryGetSystemPath(out sysPath)) { object ret = ImportFromPathHook(context, name, name, sysPath, null); if (ret != null) { return(ret); } } } SourceUnit sourceUnit; if (file != null) { sourceUnit = pc.CreateSourceUnit(new PythonFileStreamContentProvider(file), fileName, file.Encoding, SourceCodeKind.File); } else { if (!pc.DomainManager.Platform.FileExists(fileName)) { throw PythonOps.SystemError("module source file not found"); } sourceUnit = pc.CreateFileUnit(fileName, pc.DefaultEncoding, SourceCodeKind.File); } pc.GetScriptCode(sourceUnit, name, ModuleOptions.None, Compiler.CompilationMode.Lookup).Run(module.Scope); return(module); }
private static PythonModule /*!*/ LoadFromSourceUnit(CodeContext /*!*/ context, SourceUnit /*!*/ sourceCode, string /*!*/ name, string /*!*/ path) { Assert.NotNull(sourceCode, name, path); return(PythonContext.GetContext(context).CompileModule(path, name, sourceCode, ModuleOptions.Initialize | ModuleOptions.Optimized)); }
/// <summary> /// Called by the __builtin__.__import__ functions (general importing) and ScriptEngine (for site.py) /// /// level indiciates whether to perform absolute or relative imports. /// -1 indicates both should be performed /// 0 indicates only absolute imports should be performed /// Positive numbers indicate the # of parent directories to search relative to the calling module /// </summary> public static object ImportModule(CodeContext /*!*/ context, object globals, string /*!*/ modName, bool bottom, int level) { if (modName.IndexOf(Path.DirectorySeparatorChar) != -1) { throw PythonOps.ImportError("Import by filename is not supported.", modName); } string package = null; object attribute; PythonDictionary pyGlobals = globals as PythonDictionary; if (pyGlobals != null) { if (pyGlobals._storage.TryGetPackage(out attribute)) { package = attribute as string; if (package == null && attribute != null) { throw PythonOps.ValueError("__package__ set to non-string"); } } else { package = null; if (level > 0) { // explicit relative import, calculate and store __package__ object pathAttr, nameAttr; if (pyGlobals._storage.TryGetName(out nameAttr) && nameAttr is string) { if (pyGlobals._storage.TryGetPath(out pathAttr)) { pyGlobals["__package__"] = nameAttr; } else { pyGlobals["__package__"] = ((string)nameAttr).rpartition(".")[0]; } } } } } object newmod = null; string firstName; int firstDot = modName.IndexOf('.'); if (firstDot == -1) { firstName = modName; } else { firstName = modName.Substring(0, firstDot); } string finalName = null; if (level != 0) { // try a relative import // if importing a.b.c, import "a" first and then import b.c from a string name; // name of the module we are to import in relation to the current module PythonModule parentModule; List path; // path to search if (TryGetNameAndPath(context, globals, firstName, level, package, out name, out path, out parentModule)) { finalName = name; // import relative if (!TryGetExistingOrMetaPathModule(context, name, path, out newmod)) { newmod = ImportFromPath(context, firstName, name, path); if (newmod == null) { // add an indirection entry saying this module does not exist // see http://www.python.org/doc/essays/packages.html "Dummy Entries" context.LanguageContext.SystemStateModules[name] = null; } else if (parentModule != null) { parentModule.__dict__[firstName] = newmod; } } else if (firstDot == -1) { // if we imported before having the assembly // loaded and then loaded the assembly we want // to make the assembly available now. if (newmod is NamespaceTracker) { context.ShowCls = true; } } } } if (level <= 0) { // try an absolute import if (newmod == null) { object parentPkg; if (!String.IsNullOrEmpty(package) && !PythonContext.GetContext(context).SystemStateModules.TryGetValue(package, out parentPkg)) { PythonModule warnModule = new PythonModule(); warnModule.__dict__["__file__"] = package; warnModule.__dict__["__name__"] = package; ModuleContext modContext = new ModuleContext(warnModule.__dict__, context.LanguageContext); PythonOps.Warn( modContext.GlobalContext, PythonExceptions.RuntimeWarning, "Parent module '{0}' not found while handling absolute import", package); } newmod = ImportTopAbsolute(context, firstName); finalName = firstName; if (newmod == null) { return(null); } } } // now import the a.b.c etc. a needs to be included here // because the process of importing could have modified // sys.modules. string[] parts = modName.Split('.'); object next = newmod; string curName = null; for (int i = 0; i < parts.Length; i++) { curName = i == 0 ? finalName : curName + "." + parts[i]; object tmpNext; if (TryGetExistingModule(context, curName, out tmpNext)) { next = tmpNext; if (i == 0) { // need to update newmod if we pulled it out of sys.modules // just in case we're in bottom mode. newmod = next; } } else if (i != 0) { // child module isn't loaded yet, import it. next = ImportModuleFrom(context, next, parts, i); } else { // top-level module doesn't exist in sys.modules, probably // came from some weird meta path hook. newmod = next; } } return(bottom ? next : newmod); }
public object Call(CodeContext /*!*/ context, [ParamDictionary] IDictionary <object, object> kwArgs, params object[] args) { return(PythonContext.GetContext(context).CallWithKeywords(this, args, kwArgs)); }
public object Call(CodeContext /*!*/ context, params object[] args) { return(PythonContext.GetContext(context).CallSplat(this, args)); }
private static object fromkeysAny(CodeContext /*!*/ context, PythonType cls, object o, object value) { PythonDictionary pyDict; object dict; if (cls == TypeCache.Dict) { string str; ICollection ic = o as ICollection; // creating our own dict, try and get the ideal size and add w/o locks if (ic != null) { pyDict = new PythonDictionary(new CommonDictionaryStorage(ic.Count)); } else if ((str = o as string) != null) { pyDict = new PythonDictionary(str.Length); } else { pyDict = new PythonDictionary(); } IEnumerator i = PythonOps.GetEnumerator(o); while (i.MoveNext()) { pyDict._storage.AddNoLock(ref pyDict._storage, i.Current, value); } return(pyDict); } else { // call the user type constructor dict = MakeDict(context, cls); pyDict = dict as PythonDictionary; } if (pyDict != null) { // then store all the keys with their associated value IEnumerator i = PythonOps.GetEnumerator(o); while (i.MoveNext()) { pyDict[i.Current] = value; } } else { // slow path, cls.__new__ returned a user defined dictionary instead of a PythonDictionary. PythonContext pc = PythonContext.GetContext(context); IEnumerator i = PythonOps.GetEnumerator(o); while (i.MoveNext()) { pc.SetIndex(dict, i.Current, value); } } return(dict); }
public override void Add(object key, object value) { PythonContext.GetContext(_context).SetIndex(_backing, key, value); }
private static object ImportTopAbsolute(CodeContext /*!*/ context, string /*!*/ name) { //Debug.WriteLine("Importing step 4: " + name); object ret; //Debug.WriteLine("TryGetExistingModule"); if (TryGetExistingModule(context, name, out ret)) { //Debug.WriteLine("Getting existing module"); if (IsReflected(ret)) { // Even though we found something in sys.modules, we need to check if a // clr.AddReference has invalidated it. So try ImportReflected again. ret = ImportReflected(context, name) ?? ret; //Debug.WriteLine("Import refelected"); } NamespaceTracker rp = ret as NamespaceTracker; if (rp != null || ret == PythonContext.GetContext(context).ClrModule) { context.ShowCls = true; } //Debug.WriteLine("Got existing module"); return(ret); } //Debug.WriteLine("TryLoadMetaPathModule"); if (TryLoadMetaPathModule(context, name, null, out ret)) { //Debug.WriteLine("LoadMetaPathModule"); return(ret); } //Debug.WriteLine("Importing builtin"); ret = ImportBuiltin(context, name); if (ret != null) { return(ret); /*Debug.WriteLine("Imported builtin");*/ } List path; //Debug.WriteLine("Trygetsyspath"); if (PythonContext.GetContext(context).TryGetSystemPath(out path)) { //Debug.WriteLine("Importing from path"); ret = ImportFromPath(context, name, name, path); if (ret != null) { return(ret); /*Debug.WriteLine("Imported from path");*/ } } //Debug.WriteLine("Importing refelcted"); ret = ImportReflected(context, name); if (ret != null) { return(ret); /*Debug.WriteLine("Imported reflected");*/ } //Debug.WriteLine("Returning null"); return(null); }