public static PySignature GetSignature(PyScope scope, string functionName) { var s = new PySignature(); PyObject fn = scope.Get(functionName); var inspect = Py.Import("inspect"); var signature = inspect.InvokeMethod("signature", fn); var parameters = signature.GetAttr("parameters"); var keys = parameters.InvokeMethod("keys"); var argumentNames = new List <string>(); foreach (var key in keys.OfType <PyObject>()) { var p = parameters[key]; var name = p.GetAttr("name").As <string>(); argumentNames.Add(name); } PyDict annotations = new PyDict(fn.GetAttr("__annotations__")); foreach (var argumentName in argumentNames) { Type type; if (annotations.HasKey(argumentName)) { var pyType = annotations.GetItem(argumentName); type = ToClrType(pyType); } else { type = typeof(object); } s.Arguments.Add(new PyArgument { Name = argumentName, Type = type }); } Type returnType; if (annotations.HasKey("return")) { var returnPyType = annotations.GetItem("return"); returnType = ToClrType(returnPyType); } else { returnType = typeof(object); } s.ReturnType = returnType; return(s); }
public IEnumerable <YouTubeDLInfo> GetInfo(string url) { EnsureModuleExists(); var extractor = GetExtractor(url); var instance = GetInstance(extractor); var result = new List <YouTubeDLInfo>(); using (Py.GIL()) { var info = new PyDict(instance.InvokeMethod("extract_info", url.ToPython(), false.ToPython())); if (info.HasKey("entries")) { foreach (PyObject item in new PyList(info.GetItem("entries"))) { result.Add(YouTubeDLInfo.FromResult(new PyDict(item), info)); } } else { result.Add(YouTubeDLInfo.FromResult(info, info)); } } return(result); }
public void PyObjectTryConvertToFunc(string code) { Func <IEnumerable <CoarseFundamental>, Symbol[]> coarseSelector; using (Py.GIL()) { var locals = new PyDict(); PythonEngine.Exec(code, null, locals.Handle); var pyObject = locals.GetItem("coarseSelector"); pyObject.TryConvertToDelegate(out coarseSelector); } var coarse = Enumerable .Range(0, 9) .Select(x => new CoarseFundamental { Symbol = Symbol.Create(x.ToStringInvariant(), SecurityType.Equity, Market.USA), Value = x }); var symbols = coarseSelector(coarse); Assert.AreEqual(5, symbols.Length); foreach (var symbol in symbols) { var price = symbol.Value.ConvertInvariant <int>(); Assert.AreEqual(0, price % 2); } }
public void TestWithNegative() { var locals = new PyDict(); PythonEngine.Exec(@" class CmTest: def __enter__(self): print('Enter') return self def __exit__(self, t, v, tb): # Signal exception is handled by returning true return True def fail(self): return 5 / 0 a = CmTest() ", null, locals); var a = locals.GetItem("a"); Py.With(a, cmTest => { cmTest.fail(); }); }
public void TestWithPositive() { var locals = new PyDict(); PythonEngine.Exec(@" class CmTest: def __enter__(self): return self def __exit__(self, t, v, tb): # Exception not handled, return will be False pass def fail(self): return 5 / 0 a = CmTest() ", null, locals); var a = locals.GetItem("a"); try { Py.With(a, cmTest => { cmTest.fail(); }); } catch (PythonException e) { TestContext.Out.WriteLine(e.Message); Assert.IsTrue(e.Type.Name == "ZeroDivisionError"); } }
private static T GetKey <T>(PyDict obj, string key) { if (obj.HasKey(key)) { return(obj.GetItem(key).As <T>()); } return(default);
public void TestWithPositive() { var locals = new PyDict(); PythonEngine.Exec(@" class CmTest: def __enter__(self): print('Enter') return self def __exit__(self, t, v, tb): # Exception not handled, return will be False print('Exit') def fail(self): return 5 / 0 a = CmTest() ", null, locals.Handle); var a = locals.GetItem("a"); try { Py.With(a, cmTest => { cmTest.fail(); }); } catch (PythonException e) { Assert.IsTrue(e.Message.Contains("ZeroDivisionError")); } }
public void PyObjectTryConvertToNonDelegateFail() { int action; using (Py.GIL()) { var locals = new PyDict(); PythonEngine.Exec("def raise_number(a, b): raise ValueError(a * b)", null, locals.Handle); var pyObject = locals.GetItem("raise_number"); Assert.Throws <ArgumentException>(() => pyObject.TryConvertToDelegate(out action)); } }
private static PyObject CreateTestClass() { var locals = new PyDict(); PythonEngine.Exec(@" class cmTest3: def Test3(self, a1 = 1, a2 = 1, a3 = 1, a4 = 1): return a1 + a2 + a3 + a4 a = cmTest3() ", null, locals); return(locals.GetItem("a")); }
public void PyObjectTryConvertFailPython() { using (Py.GIL()) { // Try to convert a python object as a IndicatorBase<TradeBar> var locals = new PyDict(); PythonEngine.Exec("class A:\n pass", null, locals.Handle); var value = locals.GetItem("A").Invoke(); IndicatorBase <TradeBar> indicatorBaseTradeBar; bool canConvert = value.TryConvert(out indicatorBaseTradeBar); Assert.IsFalse(canConvert); Assert.IsNull(indicatorBaseTradeBar); } }
public void TestExec() { dynamic sys = Py.Import("sys"); sys.attr1 = 100; var locals = new PyDict(); locals.SetItem("sys", sys); locals.SetItem("a", new PyInt(10)); PythonEngine.Exec("c = sys.attr1 + a + 1", null, locals); object c = locals.GetItem("c").AsManagedObject(typeof(int)); Assert.AreEqual(111, c); }
private void ReloadModules() { int count = 0; var sw = new Stopwatch(); sw.Start(); var sys = PythonEngine.ImportModule("sys"); var importLib = PythonEngine.ImportModule("importlib"); var modules = new PyDict(sys.GetAttr("modules")); foreach (var key in modules.Keys().OfType <PyObject>()) { try { var name = key.As <string>(); if (modulesExcludedFormReload.Contains(name)) { continue; } var module = modules.GetItem(key); if (!name.Contains("importlib")) { if (module.HasAttr("__file__") && module.HasAttr("__name__")) { var path = module.GetAttr("__file__").As <string>(); importLib.InvokeMethod("reload", module); count += 1; } } } catch (PythonException) { } } sw.Stop(); logger.LogInformation($"[PythonModules] Reloading {count} Python modules took {sw.ElapsedMilliseconds}ms."); }
public void PyObjectTryConvertToAction2() { Action <int, decimal> action; using (Py.GIL()) { var locals = new PyDict(); PythonEngine.Exec("def raise_number(a, b): raise ValueError(a * b)", null, locals.Handle); var pyObject = locals.GetItem("raise_number"); pyObject.TryConvertToDelegate(out action); } try { action(2, 3m); Assert.Fail(); } catch (PythonException e) { Assert.AreEqual("ValueError : 6.0", e.Message); } }
public void TestGetDynamicMemberNames() { List <string> expectedMemberNames = new List <string> { "add", "getNumber", "member1", "member2" }; PyDict locals = new PyDict(); PythonEngine.Exec(@" class MemberNamesTest(object): def __init__(self): self.member1 = 123 self.member2 = 'Test string' def getNumber(self): return 123 def add(self, x, y): return x + y a = MemberNamesTest() ", null, locals.Handle); PyObject a = locals.GetItem("a"); IEnumerable <string> memberNames = a.GetDynamicMemberNames(); foreach (string expectedName in expectedMemberNames) { Assert.IsTrue(memberNames.Contains(expectedName), "Could not find member '{0}'.", expectedName); } }