public void InvokingWrappedMethod()
{
var wrapper = new WrappedCodeObject("hello_void", typeof(TestPythonClass).GetMethod("hello_void"), this);
var instance = PyTypeObject.DefaultNew <TestPythonObject>(TestPythonClass.Instance);
var method = instance.__getattribute__("hello_void") as IPyCallable;
method.Call(null, null, new object[0]);
}
public PyModuleClass(CodeObject __init__) :
base("module", __init__, new PyClass[0])
{
__instance = this;
Expression <Action <PyTypeObject> > expr = instance => DefaultNew <PyModule>(null);
var methodInfo = ((MethodCallExpression)expr.Body).Method;
__new__ = new WrappedCodeObject("__new__", methodInfo, this);
}
public PyTextIOWrapperClass(CodeObject __init__) :
base("TextIOWrapper", __init__, new[] { PyTextIOBaseClass.Instance })
{
__instance = this;
Expression <Action <PyTypeObject> > expr = instance => DefaultNew <PyTextIOWrapper>(null);
var methodInfo = ((MethodCallExpression)expr.Body).Method;
__new__ = new WrappedCodeObject("__new__", methodInfo, this);
}
/// <summary>
/// Intended to be called once by the Cloaca interpreter to create the clr module in an injectable
/// module loader.
/// </summary>
/// <returns></returns>
public static PyModule CreateClrModule()
{
var internals = new ClrModuleInternals();
var module = PyModule.Create("clr");
var addReference = new WrappedCodeObject("AddReference", internals.GetType().GetMethod("EmbeddedAddReference"), internals);
module.__dict__.Add("AddReference", addReference);
module.__dict__.Add("References", internals.references);
return(module);
}
public PyDictItemsIteratorClass(CodeObject __init__) :
base("dict_itemiterator", __init__, new PyClass[0])
{
__instance = this;
// TODO: Can this be better consolidated?
Expression <Action <PyTypeObject> > expr = instance => DefaultNew <PyDictItemsIterator>(null);
var methodInfo = ((MethodCallExpression)expr.Body).Method;
__new__ = new WrappedCodeObject("__new__", methodInfo, this);
}
public PyIntegerClass(CodeObject __init__) :
base("int", __init__, new PyClass[0])
{
__instance = this;
// We have to replace PyTypeObject.DefaultNew with one that creates a PyInteger.
// TODO: Can this be better consolidated?
Expression <Action <PyTypeObject> > expr = instance => DefaultNew <PyInteger>(null);
var methodInfo = ((MethodCallExpression)expr.Body).Method;
__new__ = new WrappedCodeObject("__new__", methodInfo, this);
}
public void EmbeddedVoid()
{
calledCount = 0;
Expression <Action <EmbeddingTests> > expr = instance => Meow();
var methodInfo = ((MethodCallExpression)expr.Body).Method;
var meowCode = new WrappedCodeObject("meow", methodInfo, this);
var interpreter = runProgram("meow()\n", new Dictionary <string, object>()
{
{ "meow", meowCode }
}, 1);
Assert.That(calledCount, Is.EqualTo(1));
}
public PyModule CreateModule()
{
var sysHandle = PyModule.Create("sys");
var schedulerHandle = PyModule.Create("scheduler");
var me = this.GetType();
var getActive = new WrappedCodeObject("get_active", me.GetMethod("getTasksActive"), this);
var getBlocked = new WrappedCodeObject("get_blocked", me.GetMethod("getTasksBlocked"), this);
var getUnblocked = new WrappedCodeObject("get_unblocked", me.GetMethod("getTasksUnblocked"), this);
var getYielded = new WrappedCodeObject("get_yielded", me.GetMethod("getTasksYielded"), this);
var schedule = new WrappedCodeObject("schedule", me.GetMethod("schedule"), this);
schedulerHandle.__dict__.Add(getActive.Name, getActive);
schedulerHandle.__dict__.Add(getBlocked.Name, getBlocked);
schedulerHandle.__dict__.Add(getUnblocked.Name, getUnblocked);
schedulerHandle.__dict__.Add(getYielded.Name, getYielded);
schedulerHandle.__dict__.Add(schedule.Name, schedule);
sysHandle.__dict__.Add("scheduler", schedulerHandle);
return(sysHandle);
}
