public object Call(CodeContext /*!*/ context, object param) { object method = PythonOps.GetBoundAttr(context, param, _name); if (_dict == null) { return(PythonOps.CallWithContext(context, method, _args)); } else { return(PythonCalls.CallWithKeywordArgs(context, method, _args, _dict)); } }
bool IEnumerator.MoveNext() { if (_index > 0) { _index--; _current = PythonCalls.Call(_getItemMethod, _index); return(true); } else { return(false); } }
public object __copy__(CodeContext /*!*/ context) { if (GetType() == typeof(deque)) { deque res = new deque(_maxLen); res.extend(((IEnumerable)this).GetEnumerator()); return(res); } else { return(PythonCalls.Call(context, DynamicHelpers.GetPythonType(this), ((IEnumerable)this).GetEnumerator())); } }
public object Call(CodeContext context, [ParamDictionary] IDictionary <object, object> dict, params object[] args) { object targetMethod; if (!DynamicHelpers.GetPythonType(target.Target).TryGetBoundMember(context, target.Target, name, out targetMethod)) { throw PythonOps.AttributeError("type {0} has no attribute {1}", DynamicHelpers.GetPythonType(target.Target), name); } return(PythonCalls.CallWithKeywordArgs(context, targetMethod, args, dict)); }
IC_PyInt_New(IntPtr typePtr, IntPtr argsPtr, IntPtr kwargsPtr) { try { PythonTuple args = (PythonTuple)this.Retrieve(argsPtr); return(this.Store(PythonCalls.Call(this.scratchContext, TypeCache.Int32, new object[] { args[0] }))); } catch (Exception e) { this.LastException = e; return(IntPtr.Zero); } }
PyNumber_Long(IntPtr numberPtr) { try { object number = this.Retrieve(numberPtr); return(this.Store(PythonCalls.Call(TypeCache.BigInteger, new object[] { number }))); } catch (Exception e) { this.LastException = e; return(IntPtr.Zero); } }
public new object __get__(CodeContext /*!*/ context, object instance, object owner) { PythonType selfType = PythonType; if (selfType == TypeCache.Super) { Super res = new Super(); res.__init__(_thisClass, instance); return(res); } return(PythonCalls.Call(context, selfType, _thisClass, instance)); }
public object cursor(CodeContext context, [Optional][DefaultParameterValue(null)] object factory) { checkThread(); checkConnection(); object cursor = factory == null ? new Cursor(context, this) : PythonCalls.Call(context, factory, this); if (this.row_factory != null) { context.LanguageContext.Operations.SetMember(cursor, "row_factory", this.row_factory); } return(cursor); }
public object Call(CodeContext context, [ParamDictionary] IDictionary <object, object> dict, params object[] args) { ValidateArgs(args); if (_inst != null) { return(PythonCalls.CallWithKeywordArgs(context, _func, ArrayUtils.Insert(_inst, args), dict)); } else { return(PythonCalls.CallWithKeywordArgs(context, _func, args, dict)); } }
LogRefs() { int wtotal = 0; int stotal = 0; Dictionary <object, int> scounts = new Dictionary <object, int>(); Dictionary <object, int> wcounts = new Dictionary <object, int>(); wcounts["ZOMBIE"] = 0; foreach (long id in this.id2wref.Keys) { if (!this.id2sref.ContainsKey(id)) { wtotal += 1; WeakReference wref = this.id2wref[id]; if (wref.IsAlive) { object type_ = PythonCalls.Call(Builtin.type, new object[] { wref.Target }); if (!wcounts.ContainsKey(type_)) { wcounts[type_] = 0; } wcounts[type_] += 1; } else { wcounts["ZOMBIE"] += 1; } } else { stotal += 1; object type_ = PythonCalls.Call(Builtin.type, new object[] { this.id2sref[id] }); if (!scounts.ContainsKey(type_)) { scounts[type_] = 0; } scounts[type_] += 1; } } Console.WriteLine("weak refs: {0}", wtotal); foreach (object type_ in wcounts.Keys) { Console.WriteLine("{0}: {1}", PythonCalls.Call(Builtin.str, new object[] { type_ }), wcounts[type_]); } Console.WriteLine("strong refs: {0}", stotal); foreach (object type_ in scounts.Keys) { Console.WriteLine("{0}: {1}", PythonCalls.Call(Builtin.str, new object[] { type_ }), scounts[type_]); } }
/// <summary> /// Attempts to convert value into a index usable for slicing and return the integer /// value. If the conversion fails false is returned. /// /// If throwOverflowError is true then BigInteger's outside the normal range of integers will /// result in an OverflowError. /// </summary> internal static bool TryConvertToIndex(object value, bool throwOverflowError, out object index) { index = ConvertToSliceIndexHelper(value, throwOverflowError); if (index == null) { object callable; if (PythonOps.TryGetBoundAttr(value, "__index__", out callable)) { index = ConvertToSliceIndexHelper(PythonCalls.Call(callable), throwOverflowError); } } return(index != null); }
Dispose(bool disposing) { if (!this.alive) { return; } this.alive = false; while (this.exitfuncs.Count > 0) { this.exitfuncs.Pop()(); } PythonDictionary modules = (PythonDictionary)this.python.SystemState.Get__dict__()["modules"]; if (!modules.Contains("numpy")) { // TODO: FIXME? // I don't know what it is about numpy, but using it heavily // makes this step extremely flaky: that's, like, BSOD flaky. // OTOH, even attempting this operation is very optimistic // indeed, and it's only really here so that I can repeatedly // construct/destroy mappers -- without leaking *too* much -- // during test runs. In the wild, all this will be reclaimed // by the operating system at process shutdown time anyway. this.map.MapOverBridgePtrs(new PtrFunc(this.DumpPtr)); } this.allocator.FreeAll(); foreach (IntPtr FILE in this.FILEs.Values) { Unmanaged.fclose(FILE); } if (this.stub != null) { PythonCalls.Call(this.removeSysHacks); modules.Remove("mmap"); modules.Remove("posix"); modules.Remove("_csv"); if (modules.Contains("csv")) { modules.Remove("csv"); } this.importer.Dispose(); this.stub.Dispose(); } }
public override void Init() { try { scriptSource = Engine.CreateScriptSourceFromFile(Path); compiledCode = scriptSource.Compile(); compiledCode.Execute(Scope); PythonFunction InitAction = (PythonFunction)GetVariable("Init"); PythonCalls.Call(codeContext, InitAction); } catch (ImportException e) { } }
public object __delslice__(CodeContext context, int i, int j) { object callable; if (TryRawGetAttr(context, "__delslice__", out callable)) { return(PythonCalls.Call(context, callable, i, j)); } else if (TryRawGetAttr(context, "__delitem__", out callable)) { return(PythonCalls.Call(context, callable, new Slice(i, j))); } throw PythonOps.TypeError("instance {0} does not have __delslice__ or __delitem__", _class.Name); }
public object Call(CodeContext context, [ParamDictionary] IDictionary <object, object> dict\u00F8, [NotNull] params object[] args\u00F8) { OldInstance inst = new OldInstance(context, this); object meth; if (PythonOps.TryGetBoundAttr(inst, "__init__", out meth)) { PythonCalls.CallWithKeywordArgs(context, meth, args\u00F8, dict\u00F8); } else if (dict\u00F8.Count > 0 || args\u00F8.Length > 0) { MakeCallError(); } return(inst); }
/// <summary> /// Attempts to convert value into a index usable for slicing and return the integer /// value. If the conversion fails false is returned. /// /// If throwOverflowError is true then BigInteger's outside the normal range of integers will /// result in an OverflowError. /// </summary> internal static bool TryConvertToIndex(object value, bool throwOverflowError, out int index) { int?res = ConvertToSliceIndexHelper(value, throwOverflowError); if (!res.HasValue) { object callable; if (PythonOps.TryGetBoundAttr(value, "__index__", out callable)) { res = ConvertToSliceIndexHelper(PythonCalls.Call(callable), throwOverflowError); } } index = res.HasValue ? res.Value : 0; return(res.HasValue); }
public bool MoveNext() { if (_index > 0) { _index--; Current = PythonCalls.Call(_getItemMethod, _index); return(true); } else { _obj = null; _getItemMethod = null; Current = null; return(false); } }
public void Init() { try { Reload(); InitThreadId = Thread.CurrentThread.ManagedThreadId; Engine.SetTrace(OnTracebackReceived); PythonFunction InitAction = (PythonFunction)GetVariable("Init"); PythonCalls.Call(codeContext, InitAction); } catch (ImportException e) { } }
public bool MoveNext() { while (_enumerator.MoveNext()) { object?o = _enumerator.Current; object?t = (_function != null) ? PythonCalls.Call(_context, _function, o) : o; if (PythonOps.IsTrue(t)) { Current = o; return(true); } } Current = default; return(false); }
public static void call_tracing(CodeContext /*!*/ context, object func, PythonTuple args) { PythonContext pyContext = (PythonContext)context.LanguageContext; pyContext.EnsureDebugContext(); pyContext.UnregisterTracebackHandler(); pyContext.PushTracebackHandler(new PythonTracebackListener((PythonContext)context.LanguageContext)); pyContext.RegisterTracebackHandler(); try { PythonCalls.Call(func, args.ToArray()); } finally { pyContext.PopTracebackHandler(); pyContext.UnregisterTracebackHandler(); } }
/// <summary> /// Converts an object into a function call parameter. /// </summary> public object from_param(Pointer obj) { if (obj == null) { return(ScriptingRuntimeHelpers.Int32ToObject(0)); } if (obj.NativeType != this) { throw PythonOps.TypeError("assign to pointer of type {0} from {1} is not valid", Name, ((PythonType)obj.NativeType).Name); } Pointer res = (Pointer)PythonCalls.Call(this); res._memHolder.WriteIntPtr(0, obj._memHolder.ReadMemoryHolder(0)); return(res); }
PyNumber_Int(IntPtr numberPtr) { try { object result = PythonCalls.Call(TypeCache.Int32, new object[] { this.Retrieve(numberPtr) }); if (!(result is Int32)) { result = Converter.ConvertToBigInteger(result); } return(this.Store(result)); } catch (Exception e) { this.LastException = e; return(IntPtr.Zero); } }
public void __setslice__(CodeContext context, int i, int j, object value) { object callable; if (TryRawGetAttr(context, "__setslice__", out callable)) { PythonCalls.Call(context, callable, i, j, value); return; } else if (TryRawGetAttr(context, "__setitem__", out callable)) { PythonCalls.Call(context, callable, new Slice(i, j), value); return; } throw PythonOps.TypeError("instance {0} does not have __setslice__ or __setitem__", _class.Name); }
private static SetCollection Make(PythonType /*!*/ cls, SetStorage items) { if (cls == TypeCache.Set) { return(new SetCollection(items)); } SetCollection res = PythonCalls.Call(cls) as SetCollection; Debug.Assert(res != null); if (items.Count > 0) { res._items = items; } return(res); }
public object __next__(CodeContext context) { object next_row_tuple, next_row; connection.checkThread(); connection.checkConnection(); if (this.next_row == null) { if (this.statement != null) { this.statement.Reset(); this.statement = null; } throw new StopIterationException(); } next_row_tuple = this.next_row; this.next_row = null; if (this.row_factory != null) { next_row = PythonCalls.Call(context, this.row_factory, this, next_row_tuple); } else { next_row = next_row_tuple; } if (this.statement != null) { int rc = this.statement.RawStep(); if (rc != Sqlite3.SQLITE_DONE && rc != Sqlite3.SQLITE_ROW) { this.statement.Reset(); throw GetSqliteError(this.connection.db, this.statement.st); } if (rc == Sqlite3.SQLITE_ROW) { this.next_row = fetchOneRow(context); } } return(next_row); }
public bool MoveNext() { if (_nextMethod == null) { if (!PythonOps.TryGetBoundAttr(_baseObject, "next", out _nextMethod) || _nextMethod == null) { throw PythonOps.TypeError("instance has no next() method"); } } try { _current = PythonCalls.Call(_nextMethod); return(true); } catch (StopIterationException) { return(false); } }
public static bool TryCreate(object baseEnumerator, out IEnumerable enumerator) { Debug.Assert(!(baseEnumerator is IEnumerable) || baseEnumerator is IPythonObject); // we shouldn't re-wrap things that don't need it object iter; if (PythonOps.TryGetBoundAttr(baseEnumerator, "__iter__", out iter)) { object iterator = PythonCalls.Call(iter); if (iterator is IEnumerable) { enumerator = (IEnumerable)iterator; } else { enumerator = new PythonEnumerable(iterator); } return true; } else { enumerator = null; return false; } }
PyObject_Str(IntPtr objPtr) { try { object obj = this.Retrieve(objPtr); if (obj is string) { return(this.Store(obj)); } return(this.Store(PythonCalls.Call(Builtin.str, new object[] { obj }))); } catch (Exception e) { this.LastException = e; return(IntPtr.Zero); } }
public static object encode(CodeContext /*!*/ context, object obj, string encoding = null, string errors = "strict") { if (encoding == null) { if (obj is string str) { PythonContext lc = context.LanguageContext; return(StringOps.DoEncode(context, str, errors, lc.GetDefaultEncodingName(), lc.DefaultEncoding, includePreamble: true)); } else { throw PythonOps.TypeError("expected str, got {0}", PythonTypeOps.GetName(obj)); } } PythonTuple t = lookup(context, encoding); return(PythonOps.GetIndex(context, PythonCalls.Call(context, t[EncoderIndex], obj, errors), 0)); }
public static object decode(CodeContext /*!*/ context, object obj, string encoding = null, string errors = "strict") { if (encoding == null) { if (obj is IList <byte> bytesLikeObj) { PythonContext lc = context.LanguageContext; return(StringOps.DoDecode(context, bytesLikeObj, errors, lc.GetDefaultEncodingName(), lc.DefaultEncoding, final: true, out _)); } else { throw PythonOps.TypeError("expected bytes-like object, got {0}", PythonTypeOps.GetName(obj)); } } PythonTuple t = lookup(context, encoding); return(PythonOps.GetIndex(context, PythonCalls.Call(context, t[DecoderIndex], obj, errors), 0)); }