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);
}
}
