void CreatePythonFunctionCache()
{
foreach (var memberName in _operations.GetMemberNames(_scriptScope))
{
if (!_operations.TryGetMember(_scriptScope, memberName, out var member))
{
continue;
}
if (member is PythonFunction pythonFunction)
{
_functionsCache.Add(memberName, pythonFunction);
}
}
}
// get an object's instance variable names
ArrayList getInstanceVars(object instance)
{
ArrayList instanceVars = new ArrayList();
foreach (var name in operations.GetMemberNames(instance))
{
object member = operations.GetMember(instance, name);
if (!operations.IsCallable(member) && !(name == "__doc__" || name == "__module__" || name == "_object")) // found an instance variable!
{
instanceVars.Add(name);
}
}
return(instanceVars);
}
private string GetMethodName(object receiver, string message)
{
var methodNames = Operations.GetMemberNames(receiver);
if (methodNames.Contains(message.Pascalize()))
{
return(message.Pascalize());
}
if (methodNames.Contains(message.Underscore()))
{
return(message.Underscore());
}
// really? we got here.. that must be some pretty funky naming.
return(message);
}
public IList <string> GetMemberNames(string expression)
{
Debug.Assert(Thread.CurrentThread != _consoleThread);
lock (_accessLock) {
if (_remoteConsoleHost == null)
{
return(null);
}
ScriptEngine engine = _remoteConsoleHost.Engine;
try {
ScriptScope scope = _remoteConsoleHost.ScriptScope;
ObjectOperations operations = engine.CreateOperations(scope);
ScriptSource src = engine.CreateScriptSourceFromString(expression, SourceCodeKind.Expression);
return(operations.GetMemberNames(src.ExecuteAndWrap(scope)));
} catch {
return(null);
}
}
}
List <ClassInfo> generateClassInfo()
{
List <ClassInfo> classInformation = new List <ClassInfo>();
char[] removeEndChars = new char[2] {
',', ' '
};
foreach (KeyValuePair <string, object> obj in objects)
{
if (obj.Key != "__doc__" && obj.Key != "PythonUnityPrimitive")
{
if (obj.Value.GetType() == typeof(IronPython.Runtime.Types.OldClass)) // if the object is a class
{
ClassInfo classInfo = new ClassInfo();
classInfo.name = obj.Key;
bool constructor = false;
object classObj = obj.Value;
foreach (string op in operations.GetMemberNames(classObj)) // for each of its members
{
string memberSignature = "";
object member = operations.GetMember(classObj, op);
if (operations.IsCallable(member) && op != "update") // if it's a function (a method) and not update which is in all classes
{
if (op == "__init__") // constructor found
{
memberSignature += classInfo.name + "(";
constructor = true;
}
else
{
memberSignature += op + "(";
constructor = false;
}
object method = operations.GetMember(member, "__func__");
Type methodType = method.GetType();
PropertyInfo property = methodType.GetProperty("ArgNames", BindingFlags.Instance | BindingFlags.NonPublic);
var arguments = property.GetValue(method, null) as string[]; // all parameters to the method
foreach (var arg in arguments) // parameters, add to the string for the method
{
if (arg != "self")
{
memberSignature += arg + ", ";
}
}
memberSignature = memberSignature.TrimEnd(removeEndChars);
memberSignature += ")";
if (constructor)
{
classInfo.constructorSignature = memberSignature;
}
else
{
classInfo.methodSigs.Add(memberSignature);
}
}
}
classInformation.Add(classInfo);
}
}
}
return(classInformation);
}
public static void try5(string[] args)
{
ScriptEngine pyEngine = Python.CreateEngine();
dynamic pyScope = pyEngine.CreateScope();
ScriptSource source = pyEngine.CreateScriptSourceFromFile("CdiClient.py");
source.Compile().Execute(pyScope);
ObjectOperations ops = pyEngine.CreateOperations(pyScope);
// create member objects for worker object: watermark provider, tracer, logger
WatermarkProvider watermarkProvider = new WatermarkProvider();
pyScope.SetVariable("watermarkProvider", watermarkProvider);
dynamic cdiWorker = pyEngine.Execute("CdiClient()", pyScope); // create an instance of the worker obj
// TODO -- check that all of the right entrypoints are available.
Console.WriteLine("static function doc: {0}", pyScope.SampleStaticFunction.__doc__);
Console.WriteLine("indirect class doc: {0}", pyScope.CdiClient.__doc__);
Console.WriteLine("direct class doc: {0}", cdiWorker.__doc__);
Console.WriteLine("class function doc: {0}", cdiWorker.ProcessOneEvent.__doc__);
//CheckForEntryPoint();
Console.WriteLine("NoOp: {0}", ops.ContainsMember(cdiWorker, "NoOp"));
Console.WriteLine("FooBar: {0}", ops.ContainsMember(cdiWorker, "FooBar"));
IList <string> memberNames = ops.GetMemberNames(cdiWorker);
foreach (string s in memberNames)
{
Console.WriteLine(" names: {0}", s);
}
IList <string> signatures = ops.GetCallSignatures(cdiWorker);
foreach (string s in signatures)
{
Console.WriteLine(" sig: {0}", s);
}
dynamic result;
result = ops.InvokeMember(cdiWorker, "NoOp", new object[] { "hi mom" });
result = ops.InvokeMember(cdiWorker, "NoOp", new object[] { "hi dad" });
result = ops.InvokeMember(cdiWorker, "NoOp", new object[] { "watch this" });
for (int i = 0; i < 10; i++)
{
MockEHEvent ehEvent = new MockEHEvent();
WatermarkData wmData = new WatermarkData();
System.Threading.Thread.Sleep(args.Length > 0 ? int.Parse(args[0]) : 100);
result = ops.InvokeMember(cdiWorker, "ProcessOneEvent", new object[] { ehEvent, wmData });
}
WatermarkDelegate del = delegate() { Console.WriteLine("delegate"); };
result = ops.InvokeMember(cdiWorker, "ProcessDelegate", new object[] { del });
WatermarkDelegateWithVal delVal = delegate(string s) { Console.WriteLine("delegate {0}", s); };
result = ops.InvokeMember(cdiWorker, "ProcessDelegateWithVal", new object[] { delVal });
}
