public static PythonModule/*!*/ __new__(CodeContext/*!*/ context, PythonType/*!*/ cls, params object[]/*!*/ args\u00F8) { PythonModule res; if (cls == TypeCache.Module) { res = new PythonModule(); } else if (cls.IsSubclassOf(TypeCache.Module)) { res = (PythonModule)cls.CreateInstance(context); } else { throw PythonOps.TypeError("{0} is not a subtype of module", cls.Name); } return res; }
public static Scope/*!*/ __new__(CodeContext/*!*/ context, PythonType/*!*/ cls, params object[]/*!*/ args\u00F8) { Scope res; if (cls == TypeCache.Module) { res = new Scope(PythonDictionary.MakeSymbolDictionary()); } else if (cls.IsSubclassOf(TypeCache.Module)) { res = (Scope)cls.CreateInstance(context); } else { throw PythonOps.TypeError("{0} is not a subtype of module", cls.Name); } PythonContext.GetContext(context).CreateModule(null, res, null, ModuleOptions.None); res.Clear(); return res; }
private PythonType CheckGetArgs(CodeContext context, object instance, PythonType owner) { if (owner == null) { if (instance == null) throw PythonOps.TypeError("__get__(None, None) is invalid"); owner = DynamicHelpers.GetPythonType(instance); } else { if (!owner.IsSubclassOf(DynamicHelpers.GetPythonTypeFromType(_func.DeclaringType))) { throw PythonOps.TypeError("descriptor {0} for type {1} doesn't apply to type {2}", PythonOps.Repr(context, _func.Name), PythonOps.Repr(context, DynamicHelpers.GetPythonTypeFromType(_func.DeclaringType).Name), PythonOps.Repr(context, owner.Name)); } } if (instance != null) BuiltinMethodDescriptor.CheckSelfWorker(context, instance, _func); return owner; }
public static void warn_explicit(CodeContext context, object message, PythonType category, string filename, int lineno, [DefaultParameterValue(null)]string module, [DefaultParameterValue(null)]PythonDictionary registry, [DefaultParameterValue(null)]object module_globals) { PythonContext pContext = PythonContext.GetContext(context); PythonDictionary fields = (PythonDictionary)pContext.GetModuleState(_keyFields); PythonExceptions.BaseException msg; string text; // message text if (string.IsNullOrEmpty(module)) { module = (filename == null || filename == "") ? "<unknown>" : filename; if (module.EndsWith(".py")) { module = module.Substring(0, module.Length - 3); } } if (registry == null) { registry = new PythonDictionary(); } if (PythonOps.IsInstance(message, PythonExceptions.Warning)) { msg = (PythonExceptions.BaseException)message; text = msg.ToString(); category = DynamicHelpers.GetPythonType(msg); } else { text = message.ToString(); msg = PythonExceptions.CreatePythonThrowable(category, message.ToString()); } PythonTuple key = PythonTuple.MakeTuple(text, category, lineno); if (registry.ContainsKey(key)) { return; } string action = Converter.ConvertToString(fields[_keyDefaultAction]); PythonTuple last_filter = null; bool loop_break = false; foreach (PythonTuple filter in (List)fields[_keyFilters]) { last_filter = filter; action = (string)filter._data[0]; PythonRegex.RE_Pattern fMsg = (PythonRegex.RE_Pattern)filter._data[1]; PythonType fCat = (PythonType)filter._data[2]; PythonRegex.RE_Pattern fMod = (PythonRegex.RE_Pattern)filter._data[3]; int fLno; if (filter._data[4] is int) { fLno = (int)filter._data[4]; } else { fLno = (Extensible<int>)filter._data[4]; } if ((fMsg == null || fMsg.match(text) != null) && category.IsSubclassOf(fCat) && (fMod == null || fMod.match(module) != null) && (fLno == 0 || fLno == lineno)) { loop_break = true; break; } } if (!loop_break) { action = Converter.ConvertToString(fields[_keyDefaultAction]); } switch (action) { case "ignore": registry.Add(key, 1); return; case "error": throw msg.GetClrException(); case "once": registry.Add(key, 1); PythonTuple onceKey = PythonTuple.MakeTuple(text, category); PythonDictionary once_reg = (PythonDictionary)fields[_keyOnceRegistry]; if (once_reg.ContainsKey(onceKey)) { return; } once_reg.Add(key, 1); break; case "always": break; case "module": registry.Add(key, 1); PythonTuple altKey = PythonTuple.MakeTuple(text, category, 0); if (registry.ContainsKey(altKey)) { return; } registry.Add(altKey, 1); break; case "default": registry.Add(key, 1); break; default: throw PythonOps.RuntimeError("Unrecognized action ({0}) in warnings.filters:\n {1}", action, last_filter); } object warnings = pContext.GetWarningsModule(); if (warnings != null) { PythonCalls.Call( context, PythonOps.GetBoundAttr(context, warnings, "showwarning"), msg, category, filename, lineno, null, null); } else { showwarning(context, msg, category, filename, lineno, null, null); } }
private static bool ShouldInvokeInit(PythonType cls, PythonType newObjectType, int argCnt) { // don't run __init__ if it's not a subclass of ourselves, // or if this is the user doing type(x), or if it's a standard // .NET type which doesn't have an __init__ method (this is a perf optimization) return (!cls.IsSystemType || cls.IsPythonType) && newObjectType.IsSubclassOf(cls) && (cls != TypeCache.PythonType || argCnt > 1); }
private bool SubclassImpl(PythonType sub) { if (UnderlyingSystemType.IsInterface) { // interfaces aren't in bases, and therefore IsSubclassOf doesn't do this check. if (UnderlyingSystemType.IsAssignableFrom(sub.UnderlyingSystemType)) { return true; } } return sub.IsSubclassOf(this); }