public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
if (this.IsCallable())
{
PyTuple pyargs = null;
PyDict kwargs = null;
try {
GetArgs(args, binder.CallInfo, out pyargs, out kwargs);
result = CheckNone(Invoke(pyargs, kwargs));
}
finally {
if (null != pyargs)
{
pyargs.Dispose();
}
if (null != kwargs)
{
kwargs.Dispose();
}
}
return(true);
}
else
{
return(base.TryInvoke(binder, args, out result));
}
}
/// <summary>
/// Initialize Method
/// </summary>
/// <remarks>
/// Initialize the Python runtime. It is safe to call this method
/// more than once, though initialization will only happen on the
/// first call. It is *not* necessary to hold the Python global
/// interpreter lock (GIL) to call this method.
/// initSigs can be set to 1 to do default python signal configuration. This will override the way signals are handled by the application.
/// </remarks>
public static void Initialize(IEnumerable <string> args, bool setSysArgv = true, bool initSigs = false)
{
if (!initialized)
{
// Creating the delegateManager MUST happen before Runtime.Initialize
// is called. If it happens afterwards, DelegateManager's CodeGenerator
// throws an exception in its ctor. This exception is eaten somehow
// during an initial "import clr", and the world ends shortly thereafter.
// This is probably masking some bad mojo happening somewhere in Runtime.Initialize().
delegateManager = new DelegateManager();
Runtime.Initialize(initSigs);
initialized = true;
Exceptions.Clear();
// Make sure we clean up properly on app domain unload.
AppDomain.CurrentDomain.DomainUnload += OnDomainUnload;
// Remember to shut down the runtime.
AddShutdownHandler(Runtime.Shutdown);
// The global scope gets used implicitly quite early on, remember
// to clear it out when we shut down.
AddShutdownHandler(PyScopeManager.Global.Clear);
if (setSysArgv)
{
Py.SetArgv(args);
}
// register the atexit callback (this doesn't use Py_AtExit as the C atexit
// callbacks are called after python is fully finalized but the python ones
// are called while the python engine is still running).
string code =
"import atexit, clr\n" +
"atexit.register(clr._AtExit)\n";
PythonEngine.Exec(code);
// Load the clr.py resource into the clr module
IntPtr clr = pyRevitLabs.PythonNet.ImportHook.GetCLRModule();
IntPtr clr_dict = Runtime.PyModule_GetDict(clr);
var locals = new PyDict();
try {
IntPtr module = Runtime.PyImport_AddModule("clr._extras");
IntPtr module_globals = Runtime.PyModule_GetDict(module);
IntPtr builtins = Runtime.PyEval_GetBuiltins();
Runtime.PyDict_SetItemString(module_globals, "__builtins__", builtins);
Assembly assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream("clr.py"))
using (var reader = new StreamReader(stream)) {
// add the contents of clr.py to the module
string clr_py = reader.ReadToEnd();
Exec(clr_py, module_globals, locals.Handle);
}
// add the imported module to the clr module, and copy the API functions
// and decorators into the main clr module.
Runtime.PyDict_SetItemString(clr_dict, "_extras", module);
foreach (PyObject key in locals.Keys())
{
if (!key.ToString().StartsWith("_") || key.ToString().Equals("__version__"))
{
PyObject value = locals[key];
Runtime.PyDict_SetItem(clr_dict, key.Handle, value.Handle);
value.Dispose();
}
key.Dispose();
}
}
finally {
locals.Dispose();
}
}
}