add a scope class to manage the context of interaction with Python an… (#381)
* add a scope class to manage the context of interaction with Python and simplify the variable exchanging * Deprecate public RunString Had to remove defaults to disambiguate call on `internal RunString`. Can re-add after removing `public RunString` Closes #401 * Rename several methods and add three methods Referring to IronPython, change the name of the methods Get, Exists, SetLocal, DelLocal to GetVariable, ContainsVariable, SetVariable, RemoveVariable. Hidden the methods SetGlobalVariable, RemoveGlobalVariable. Add a new method 'Compile' to compile string into ast, the ast can be seen as the ScriptSource of IronPython. Add two new methods 'Execute' and 'Execute<T>' to execute an ast and obtain the result, corresponding to the 'Execute' method of IronPython. * rebased * Rebased update * format cleanup * create unnamed pyscope, make PyScope.GILState save remove method GetInstHandle add function to create unnamed pyscope add a field isDisposed for PyScope.GILState to make it more save * fixup! create unnamed pyscope, make PyScope.GILState save * remove GIL and rebased * Add several methods add ImportScope: a scope can import variable from any scope, equivalent to python 'import * from mod' add dynamic member support add an OnDispose event remove the field ‘globals’ referring to python module put the scope class in a new file Unit test: TestThread uses scope function replacing Exec/Eval to speed up the execution. * add a Variables method * fixup! add a Variables method * remove private method _GetVariable * add unit test for Variables() method * add several methods and rebased Add an optional dict parameter for Eval/Exec/Execute methods Add a new field obj which point to a Python Module (same as pyobject) Add a static method New Rename the old ImportScope method to ImportAllFromScope Add a new ImportScope method and add a unit test for it Rename the CreateScope method to NewScope * add a new class PyScopeManager * cleaned up the Import methods * updated according to filmor's comments * fixup! updated according to filmor's comments * Get/Set Methods renamed
This commit is contained in:
yagweb
denfromufa
Родитель
aef02e2548
Коммит
550a02737f
|
|
@ -100,6 +100,7 @@
|
|||
<Compile Include="TestNamedArguments.cs" />
|
||||
<Compile Include="TestPyWith.cs" />
|
||||
<Compile Include="TestRuntime.cs" />
|
||||
<Compile Include="TestPyScope.cs" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\runtime\Python.Runtime.csproj">
|
||||
|
|
|
|||
|
|
@ -0,0 +1,372 @@
|
|||
using System;
|
||||
using NUnit.Framework;
|
||||
using Python.Runtime;
|
||||
|
||||
namespace Python.EmbeddingTest
|
||||
{
|
||||
public class PyScopeTest
|
||||
{
|
||||
private PyScope ps;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps = Py.CreateScope("test");
|
||||
}
|
||||
}
|
||||
|
||||
[TearDown]
|
||||
public void Dispose()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Dispose();
|
||||
ps = null;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Eval a Python expression and obtain its return value.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestEval()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("a", 1);
|
||||
var result = ps.Eval<int>("a + 2");
|
||||
Assert.AreEqual(3, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Exec Python statements and obtain the variables created.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestExec()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100); //declare a global variable
|
||||
ps.Set("cc", 10); //declare a local variable
|
||||
ps.Exec("aa = bb + cc + 3");
|
||||
var result = ps.Get<int>("aa");
|
||||
Assert.AreEqual(113, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compile an expression into an ast object;
|
||||
/// Execute the ast and obtain its return value.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestCompileExpression()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100); //declare a global variable
|
||||
ps.Set("cc", 10); //declare a local variable
|
||||
PyObject script = PythonEngine.Compile("bb + cc + 3", "", RunFlagType.Eval);
|
||||
var result = ps.Execute<int>(script);
|
||||
Assert.AreEqual(113, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Compile Python statements into an ast object;
|
||||
/// Execute the ast;
|
||||
/// Obtain the local variables created.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestCompileStatements()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100); //declare a global variable
|
||||
ps.Set("cc", 10); //declare a local variable
|
||||
PyObject script = PythonEngine.Compile("aa = bb + cc + 3", "", RunFlagType.File);
|
||||
ps.Execute(script);
|
||||
var result = ps.Get<int>("aa");
|
||||
Assert.AreEqual(113, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a function in the scope, then the function can read variables in the scope.
|
||||
/// It cannot write the variables unless it uses the 'global' keyword.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestScopeFunction()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100);
|
||||
ps.Set("cc", 10);
|
||||
ps.Exec(
|
||||
"def func1():\n" +
|
||||
" bb = cc + 10\n");
|
||||
dynamic func1 = ps.Get("func1");
|
||||
func1(); //call the function, it can be called any times
|
||||
var result = ps.Get<int>("bb");
|
||||
Assert.AreEqual(100, result);
|
||||
|
||||
ps.Set("bb", 100);
|
||||
ps.Set("cc", 10);
|
||||
ps.Exec(
|
||||
"def func2():\n" +
|
||||
" global bb\n" +
|
||||
" bb = cc + 10\n");
|
||||
dynamic func2 = ps.Get("func2");
|
||||
func2();
|
||||
result = ps.Get<int>("bb");
|
||||
Assert.AreEqual(20, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a class in the scope, the class can read variables in the scope.
|
||||
/// Its methods can write the variables with the help of 'global' keyword.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestScopeClass()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
dynamic _ps = ps;
|
||||
_ps.bb = 100;
|
||||
ps.Exec(
|
||||
"class Class1():\n" +
|
||||
" def __init__(self, value):\n" +
|
||||
" self.value = value\n" +
|
||||
" def call(self, arg):\n" +
|
||||
" return self.value + bb + arg\n" + //use scope variables
|
||||
" def update(self, arg):\n" +
|
||||
" global bb\n" +
|
||||
" bb = self.value + arg\n" //update scope variable
|
||||
);
|
||||
dynamic obj1 = _ps.Class1(20);
|
||||
var result = obj1.call(10).As<int>();
|
||||
Assert.AreEqual(130, result);
|
||||
|
||||
obj1.update(10);
|
||||
result = ps.Get<int>("bb");
|
||||
Assert.AreEqual(30, result);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Import a python module into the session.
|
||||
/// Equivalent to the Python "import" statement.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestImportModule()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
dynamic sys = ps.Import("sys");
|
||||
Assert.IsTrue(ps.Contains("sys"));
|
||||
|
||||
ps.Exec("sys.attr1 = 2");
|
||||
var value1 = ps.Eval<int>("sys.attr1");
|
||||
var value2 = sys.attr1.As<int>();
|
||||
Assert.AreEqual(2, value1);
|
||||
Assert.AreEqual(2, value2);
|
||||
|
||||
//import as
|
||||
ps.Import("sys", "sys1");
|
||||
Assert.IsTrue(ps.Contains("sys1"));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a scope and import variables from a scope,
|
||||
/// exec Python statements in the scope then discard it.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestImportScope()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100);
|
||||
ps.Set("cc", 10);
|
||||
|
||||
using (var scope = Py.CreateScope())
|
||||
{
|
||||
scope.Import(ps, "ps");
|
||||
scope.Exec("aa = ps.bb + ps.cc + 3");
|
||||
var result = scope.Get<int>("aa");
|
||||
Assert.AreEqual(113, result);
|
||||
}
|
||||
|
||||
Assert.IsFalse(ps.Contains("aa"));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a scope and import variables from a scope,
|
||||
/// exec Python statements in the scope then discard it.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestImportAllFromScope()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100);
|
||||
ps.Set("cc", 10);
|
||||
|
||||
using (var scope = ps.NewScope())
|
||||
{
|
||||
scope.Exec("aa = bb + cc + 3");
|
||||
var result = scope.Get<int>("aa");
|
||||
Assert.AreEqual(113, result);
|
||||
}
|
||||
|
||||
Assert.IsFalse(ps.Contains("aa"));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a scope and import variables from a scope,
|
||||
/// call the function imported.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestImportScopeFunction()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100);
|
||||
ps.Set("cc", 10);
|
||||
ps.Exec(
|
||||
"def func1():\n" +
|
||||
" return cc + bb\n");
|
||||
|
||||
using (PyScope scope = ps.NewScope())
|
||||
{
|
||||
//'func1' is imported from the origion scope
|
||||
scope.Exec(
|
||||
"def func2():\n" +
|
||||
" return func1() - cc - bb\n");
|
||||
dynamic func2 = scope.Get("func2");
|
||||
|
||||
var result1 = func2().As<int>();
|
||||
Assert.AreEqual(0, result1);
|
||||
|
||||
scope.Set("cc", 20);//it has no effect on the globals of 'func1'
|
||||
var result2 = func2().As<int>();
|
||||
Assert.AreEqual(-10, result2);
|
||||
scope.Set("cc", 10); //rollback
|
||||
|
||||
ps.Set("cc", 20);
|
||||
var result3 = func2().As<int>();
|
||||
Assert.AreEqual(10, result3);
|
||||
ps.Set("cc", 10); //rollback
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Import a python module into the session with a new name.
|
||||
/// Equivalent to the Python "import .. as .." statement.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestImportScopeByName()
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
ps.Set("bb", 100);
|
||||
|
||||
using (var scope = Py.CreateScope())
|
||||
{
|
||||
scope.ImportAll("test");
|
||||
//scope.ImportModule("test");
|
||||
|
||||
Assert.IsTrue(scope.Contains("bb"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Use the locals() and globals() method just like in python module
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestVariables()
|
||||
{
|
||||
(ps.Variables() as dynamic)["ee"] = new PyInt(200);
|
||||
var a0 = ps.Get<int>("ee");
|
||||
Assert.AreEqual(200, a0);
|
||||
|
||||
ps.Exec("locals()['ee'] = 210");
|
||||
var a1 = ps.Get<int>("ee");
|
||||
Assert.AreEqual(210, a1);
|
||||
|
||||
ps.Exec("globals()['ee'] = 220");
|
||||
var a2 = ps.Get<int>("ee");
|
||||
Assert.AreEqual(220, a2);
|
||||
|
||||
using (var item = ps.Variables())
|
||||
{
|
||||
item["ee"] = new PyInt(230);
|
||||
}
|
||||
var a3 = ps.Get<int>("ee");
|
||||
Assert.AreEqual(230, a3);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Share a pyscope by multiple threads.
|
||||
/// </summary>
|
||||
[Test]
|
||||
public void TestThread()
|
||||
{
|
||||
//After the proposal here https://github.com/pythonnet/pythonnet/pull/419 complished,
|
||||
//the BeginAllowThreads statement blow and the last EndAllowThreads statement
|
||||
//should be removed.
|
||||
dynamic _ps = ps;
|
||||
var ts = PythonEngine.BeginAllowThreads();
|
||||
using (Py.GIL())
|
||||
{
|
||||
_ps.res = 0;
|
||||
_ps.bb = 100;
|
||||
_ps.th_cnt = 0;
|
||||
//add function to the scope
|
||||
//can be call many times, more efficient than ast
|
||||
ps.Exec(
|
||||
"def update():\n" +
|
||||
" global res, th_cnt\n" +
|
||||
" res += bb + 1\n" +
|
||||
" th_cnt += 1\n"
|
||||
);
|
||||
}
|
||||
int th_cnt = 3;
|
||||
for (int i =0; i< th_cnt; i++)
|
||||
{
|
||||
System.Threading.Thread th = new System.Threading.Thread(()=>
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
//ps.GetVariable<dynamic>("update")(); //call the scope function dynamicly
|
||||
_ps.update();
|
||||
}
|
||||
});
|
||||
th.Start();
|
||||
}
|
||||
//equivalent to Thread.Join, make the main thread join the GIL competition
|
||||
int cnt = 0;
|
||||
while(cnt != th_cnt)
|
||||
{
|
||||
using (Py.GIL())
|
||||
{
|
||||
cnt = ps.Get<int>("th_cnt");
|
||||
}
|
||||
System.Threading.Thread.Sleep(10);
|
||||
}
|
||||
using (Py.GIL())
|
||||
{
|
||||
var result = ps.Get<int>("res");
|
||||
Assert.AreEqual(101* th_cnt, result);
|
||||
}
|
||||
PythonEngine.EndAllowThreads(ts);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
|
||||
<PropertyGroup>
|
||||
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
|
||||
|
|
@ -127,6 +127,7 @@
|
|||
<Compile Include="pylong.cs" />
|
||||
<Compile Include="pynumber.cs" />
|
||||
<Compile Include="pyobject.cs" />
|
||||
<Compile Include="pyscope.cs" />
|
||||
<Compile Include="pysequence.cs" />
|
||||
<Compile Include="pystring.cs" />
|
||||
<Compile Include="pythonengine.cs" />
|
||||
|
|
|
|||
|
|
@ -96,6 +96,27 @@ namespace Python.Runtime
|
|||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// As Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Return a managed object of the given type, based on the
|
||||
/// value of the Python object.
|
||||
/// </remarks>
|
||||
public T As<T>()
|
||||
{
|
||||
if (typeof(T) == typeof(PyObject) || typeof(T) == typeof(object))
|
||||
{
|
||||
return (T)(this as object);
|
||||
}
|
||||
object result;
|
||||
if (!Converter.ToManaged(obj, typeof(T), out result, false))
|
||||
{
|
||||
throw new InvalidCastException("cannot convert object to target type");
|
||||
}
|
||||
return (T)result;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,655 @@
|
|||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Dynamic;
|
||||
|
||||
namespace Python.Runtime
|
||||
{
|
||||
public class PyScopeException : Exception
|
||||
{
|
||||
public PyScopeException(string message)
|
||||
: base(message)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Classes/methods have this attribute must be used with GIL obtained.
|
||||
/// </summary>
|
||||
public class PyGILAttribute : Attribute
|
||||
{
|
||||
}
|
||||
|
||||
[PyGIL]
|
||||
public class PyScope : DynamicObject, IDisposable
|
||||
{
|
||||
public readonly string Name;
|
||||
|
||||
/// <summary>
|
||||
/// the python Module object the scope associated with.
|
||||
/// </summary>
|
||||
internal readonly IntPtr obj;
|
||||
|
||||
/// <summary>
|
||||
/// the variable dict of the scope.
|
||||
/// </summary>
|
||||
internal readonly IntPtr variables;
|
||||
|
||||
private bool _isDisposed;
|
||||
|
||||
/// <summary>
|
||||
/// The Manager this scope associated with.
|
||||
/// It provides scopes this scope can import.
|
||||
/// </summary>
|
||||
internal readonly PyScopeManager Manager;
|
||||
|
||||
/// <summary>
|
||||
/// event which will be triggered after the scope disposed.
|
||||
/// </summary>
|
||||
public event Action<PyScope> OnDispose;
|
||||
|
||||
/// <summary>
|
||||
/// Constructor
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Create a scope based on a Python Module.
|
||||
/// </remarks>
|
||||
internal PyScope(IntPtr ptr, PyScopeManager manager)
|
||||
{
|
||||
if (Runtime.PyObject_Type(ptr) != Runtime.PyModuleType)
|
||||
{
|
||||
throw new PyScopeException("object is not a module");
|
||||
}
|
||||
Manager = manager ?? PyScopeManager.Global;
|
||||
obj = ptr;
|
||||
//Refcount of the variables not increase
|
||||
variables = Runtime.PyModule_GetDict(obj);
|
||||
if (variables == IntPtr.Zero)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
Runtime.PyDict_SetItemString(
|
||||
variables, "__builtins__",
|
||||
Runtime.PyEval_GetBuiltins()
|
||||
);
|
||||
this.Name = this.Get<string>("__name__");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// return the variable dict of the scope.
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public PyDict Variables()
|
||||
{
|
||||
Runtime.XIncref(variables);
|
||||
return new PyDict(variables);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a scope, and import all from this scope
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public PyScope NewScope()
|
||||
{
|
||||
var scope = Manager.Create();
|
||||
scope.ImportAll(this);
|
||||
return scope;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Import method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Import a scope or a module of given name,
|
||||
/// scope will be looked up first.
|
||||
/// </remarks>
|
||||
public dynamic Import(string name, string asname = null)
|
||||
{
|
||||
Check();
|
||||
if (String.IsNullOrEmpty(asname))
|
||||
{
|
||||
asname = name;
|
||||
}
|
||||
PyScope scope;
|
||||
Manager.TryGet(name, out scope);
|
||||
if (scope != null)
|
||||
{
|
||||
Import(scope, asname);
|
||||
return scope;
|
||||
}
|
||||
else
|
||||
{
|
||||
PyObject module = PythonEngine.ImportModule(name);
|
||||
Import(module, asname);
|
||||
return module;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Import method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Import a scope as a variable of given name.
|
||||
/// </remarks>
|
||||
public void Import(PyScope scope, string asname)
|
||||
{
|
||||
this.Set(asname, scope.obj);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Import Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The 'import .. as ..' statement in Python.
|
||||
/// Import a module as a variable into the scope.
|
||||
/// </remarks>
|
||||
public void Import(PyObject module, string asname = null)
|
||||
{
|
||||
if (String.IsNullOrEmpty(asname))
|
||||
{
|
||||
asname = module.GetAttr("__name__").As<string>();
|
||||
}
|
||||
Set(asname, module);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// ImportAll Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The 'import * from ..' statement in Python.
|
||||
/// Import all content of a scope/module of given name into the scope, scope will be looked up first.
|
||||
/// </remarks>
|
||||
public void ImportAll(string name)
|
||||
{
|
||||
PyScope scope;
|
||||
Manager.TryGet(name, out scope);
|
||||
if (scope != null)
|
||||
{
|
||||
ImportAll(scope);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
PyObject module = PythonEngine.ImportModule(name);
|
||||
ImportAll(module);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// ImportAll Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Import all variables of the scope into this scope.
|
||||
/// </remarks>
|
||||
public void ImportAll(PyScope scope)
|
||||
{
|
||||
int result = Runtime.PyDict_Update(variables, scope.variables);
|
||||
if (result < 0)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// ImportAll Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Import all variables of the module into this scope.
|
||||
/// </remarks>
|
||||
public void ImportAll(PyObject module)
|
||||
{
|
||||
if (Runtime.PyObject_Type(module.obj) != Runtime.PyModuleType)
|
||||
{
|
||||
throw new PyScopeException("object is not a module");
|
||||
}
|
||||
var module_dict = Runtime.PyModule_GetDict(module.obj);
|
||||
int result = Runtime.PyDict_Update(variables, module_dict);
|
||||
if (result < 0)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// ImportAll Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Import all variables in the dictionary into this scope.
|
||||
/// </remarks>
|
||||
public void ImportAll(PyDict dict)
|
||||
{
|
||||
int result = Runtime.PyDict_Update(variables, dict.obj);
|
||||
if (result < 0)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Execute method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Execute a Python ast and return the result as a PyObject.
|
||||
/// The ast can be either an expression or stmts.
|
||||
/// </remarks>
|
||||
public PyObject Execute(PyObject script, PyDict locals = null)
|
||||
{
|
||||
Check();
|
||||
IntPtr _locals = locals == null ? variables : locals.obj;
|
||||
IntPtr ptr = Runtime.PyEval_EvalCode(script.Handle, variables, _locals);
|
||||
Runtime.CheckExceptionOccurred();
|
||||
if (ptr == Runtime.PyNone)
|
||||
{
|
||||
Runtime.XDecref(ptr);
|
||||
return null;
|
||||
}
|
||||
return new PyObject(ptr);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Execute method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Execute a Python ast and return the result as a PyObject,
|
||||
/// and convert the result to a Managed Object of given type.
|
||||
/// The ast can be either an expression or stmts.
|
||||
/// </remarks>
|
||||
public T Execute<T>(PyObject script, PyDict locals = null)
|
||||
{
|
||||
Check();
|
||||
PyObject pyObj = Execute(script, locals);
|
||||
if (pyObj == null)
|
||||
{
|
||||
return default(T);
|
||||
}
|
||||
var obj = pyObj.As<T>();
|
||||
return obj;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Eval method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Evaluate a Python expression and return the result as a PyObject
|
||||
/// or null if an exception is raised.
|
||||
/// </remarks>
|
||||
public PyObject Eval(string code, PyDict locals = null)
|
||||
{
|
||||
Check();
|
||||
IntPtr _locals = locals == null ? variables : locals.obj;
|
||||
var flag = (IntPtr)Runtime.Py_eval_input;
|
||||
IntPtr ptr = Runtime.PyRun_String(
|
||||
code, flag, variables, _locals
|
||||
);
|
||||
Runtime.CheckExceptionOccurred();
|
||||
return new PyObject(ptr);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Evaluate a Python expression
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Evaluate a Python expression
|
||||
/// and convert the result to a Managed Object of given type.
|
||||
/// </remarks>
|
||||
public T Eval<T>(string code, PyDict locals = null)
|
||||
{
|
||||
Check();
|
||||
PyObject pyObj = Eval(code, locals);
|
||||
var obj = pyObj.As<T>();
|
||||
return obj;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Exec Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Exec a Python script and save its local variables in the current local variable dict.
|
||||
/// </remarks>
|
||||
public void Exec(string code, PyDict locals = null)
|
||||
{
|
||||
Check();
|
||||
IntPtr _locals = locals == null ? variables : locals.obj;
|
||||
Exec(code, variables, _locals);
|
||||
}
|
||||
|
||||
private void Exec(string code, IntPtr _globals, IntPtr _locals)
|
||||
{
|
||||
var flag = (IntPtr)Runtime.Py_file_input;
|
||||
IntPtr ptr = Runtime.PyRun_String(
|
||||
code, flag, _globals, _locals
|
||||
);
|
||||
Runtime.CheckExceptionOccurred();
|
||||
if (ptr != Runtime.PyNone)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
Runtime.XDecref(ptr);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set Variable Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Add a new variable to the variables dict if it not exist
|
||||
/// or update its value if the variable exists.
|
||||
/// </remarks>
|
||||
public void Set(string name, object value)
|
||||
{
|
||||
IntPtr _value = Converter.ToPython(value, value?.GetType());
|
||||
Set(name, _value);
|
||||
Runtime.XDecref(_value);
|
||||
}
|
||||
|
||||
private void Set(string name, IntPtr value)
|
||||
{
|
||||
Check();
|
||||
using (var pyKey = new PyString(name))
|
||||
{
|
||||
int r = Runtime.PyObject_SetItem(variables, pyKey.obj, value);
|
||||
if (r < 0)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Remove Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Remove a variable from the variables dict.
|
||||
/// </remarks>
|
||||
public void Remove(string name)
|
||||
{
|
||||
Check();
|
||||
using (var pyKey = new PyString(name))
|
||||
{
|
||||
int r = Runtime.PyObject_DelItem(variables, pyKey.obj);
|
||||
if (r < 0)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Contains Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Returns true if the variable exists in the scope.
|
||||
/// </remarks>
|
||||
public bool Contains(string name)
|
||||
{
|
||||
Check();
|
||||
using (var pyKey = new PyString(name))
|
||||
{
|
||||
return Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Returns the value of the variable of given name.
|
||||
/// If the variable does not exist, throw an Exception.
|
||||
/// </remarks>
|
||||
public PyObject Get(string name)
|
||||
{
|
||||
PyObject scope;
|
||||
var state = TryGet(name, out scope);
|
||||
if(!state)
|
||||
{
|
||||
throw new PyScopeException($"The scope of name '{Name}' has no attribute '{name}'");
|
||||
}
|
||||
return scope;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// TryGet Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Returns the value of the variable, local variable first.
|
||||
/// If the variable does not exist, return null.
|
||||
/// </remarks>
|
||||
public bool TryGet(string name, out PyObject value)
|
||||
{
|
||||
Check();
|
||||
using (var pyKey = new PyString(name))
|
||||
{
|
||||
if (Runtime.PyMapping_HasKey(variables, pyKey.obj) != 0)
|
||||
{
|
||||
IntPtr op = Runtime.PyObject_GetItem(variables, pyKey.obj);
|
||||
if (op == IntPtr.Zero)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
if (op == Runtime.PyNone)
|
||||
{
|
||||
Runtime.XDecref(op);
|
||||
value = null;
|
||||
return true;
|
||||
}
|
||||
value = new PyObject(op);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
value = null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Obtain the value of the variable of given name,
|
||||
/// and convert the result to a Managed Object of given type.
|
||||
/// If the variable does not exist, throw an Exception.
|
||||
/// </remarks>
|
||||
public T Get<T>(string name)
|
||||
{
|
||||
Check();
|
||||
PyObject pyObj = Get(name);
|
||||
if (pyObj == null)
|
||||
{
|
||||
return default(T);
|
||||
}
|
||||
return pyObj.As<T>();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// TryGet Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Obtain the value of the variable of given name,
|
||||
/// and convert the result to a Managed Object of given type.
|
||||
/// If the variable does not exist, return false.
|
||||
/// </remarks>
|
||||
public bool TryGet<T>(string name, out T value)
|
||||
{
|
||||
Check();
|
||||
PyObject pyObj;
|
||||
var result = TryGet(name, out pyObj);
|
||||
if (!result)
|
||||
{
|
||||
value = default(T);
|
||||
return false;
|
||||
}
|
||||
if (pyObj == null)
|
||||
{
|
||||
if(typeof(T).IsValueType)
|
||||
{
|
||||
throw new PyScopeException($"The value of the attribute '{name}' is None which cannot be convert to '{typeof(T).ToString()}'");
|
||||
}
|
||||
else
|
||||
{
|
||||
value = default(T);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
value = pyObj.As<T>();
|
||||
return true;
|
||||
}
|
||||
|
||||
public override bool TryGetMember(GetMemberBinder binder, out object result)
|
||||
{
|
||||
result = this.Get(binder.Name);
|
||||
return true;
|
||||
}
|
||||
|
||||
public override bool TrySetMember(SetMemberBinder binder, object value)
|
||||
{
|
||||
this.Set(binder.Name, value);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void Check()
|
||||
{
|
||||
if (_isDisposed)
|
||||
{
|
||||
throw new PyScopeException($"The scope of name '{Name}' object has been disposed");
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (_isDisposed)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_isDisposed = true;
|
||||
Runtime.XDecref(obj);
|
||||
this.OnDispose?.Invoke(this);
|
||||
}
|
||||
|
||||
~PyScope()
|
||||
{
|
||||
Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
public class PyScopeManager
|
||||
{
|
||||
public readonly static PyScopeManager Global = new PyScopeManager();
|
||||
|
||||
private Dictionary<string, PyScope> NamedScopes = new Dictionary<string, PyScope>();
|
||||
|
||||
internal PyScope NewScope(string name)
|
||||
{
|
||||
if (name == null)
|
||||
{
|
||||
name = "";
|
||||
}
|
||||
var module = Runtime.PyModule_New(name);
|
||||
if (module == IntPtr.Zero)
|
||||
{
|
||||
throw new PythonException();
|
||||
}
|
||||
return new PyScope(module, this);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Create an anonymous scope.
|
||||
/// </remarks>
|
||||
[PyGIL]
|
||||
public PyScope Create()
|
||||
{
|
||||
var scope = this.NewScope(null);
|
||||
return scope;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Create an named scope of given name.
|
||||
/// </remarks>
|
||||
[PyGIL]
|
||||
public PyScope Create(string name)
|
||||
{
|
||||
if (String.IsNullOrEmpty(name))
|
||||
{
|
||||
throw new ArgumentNullException(nameof(name));
|
||||
}
|
||||
if (name != null && Contains(name))
|
||||
{
|
||||
throw new PyScopeException($"A scope of name '{name}' does already exist");
|
||||
}
|
||||
var scope = this.NewScope(name);
|
||||
scope.OnDispose += Remove;
|
||||
NamedScopes[name] = scope;
|
||||
return scope;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Contains Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// return true if the scope exists in this manager.
|
||||
/// </remarks>
|
||||
public bool Contains(string name)
|
||||
{
|
||||
return NamedScopes.ContainsKey(name);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Find the scope in this manager.
|
||||
/// If the scope not exist, an Exception will be thrown.
|
||||
/// </remarks>
|
||||
public PyScope Get(string name)
|
||||
{
|
||||
if (String.IsNullOrEmpty(name))
|
||||
{
|
||||
throw new ArgumentNullException(nameof(name));
|
||||
}
|
||||
if (NamedScopes.ContainsKey(name))
|
||||
{
|
||||
return NamedScopes[name];
|
||||
}
|
||||
throw new PyScopeException($"There is no scope named '{name}' registered in this manager");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Try to find the scope in this manager.
|
||||
/// </remarks>
|
||||
public bool TryGet(string name, out PyScope scope)
|
||||
{
|
||||
return NamedScopes.TryGetValue(name, out scope);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Remove Method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// remove the scope from this manager.
|
||||
/// </remarks>
|
||||
public void Remove(PyScope scope)
|
||||
{
|
||||
NamedScopes.Remove(scope.Name);
|
||||
}
|
||||
|
||||
[PyGIL]
|
||||
public void Clear()
|
||||
{
|
||||
var scopes = NamedScopes.Values.ToList();
|
||||
foreach (var scope in scopes)
|
||||
{
|
||||
scope.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -294,6 +294,7 @@ namespace Python.Runtime
|
|||
{
|
||||
if (initialized)
|
||||
{
|
||||
PyScopeManager.Global.Clear();
|
||||
Marshal.FreeHGlobal(_pythonHome);
|
||||
_pythonHome = IntPtr.Zero;
|
||||
Marshal.FreeHGlobal(_programName);
|
||||
|
|
@ -421,6 +422,13 @@ namespace Python.Runtime
|
|||
return new PyObject(m);
|
||||
}
|
||||
|
||||
public static PyObject Compile(string code, string filename = "", RunFlagType mode = RunFlagType.File)
|
||||
{
|
||||
var flag = (IntPtr)mode;
|
||||
IntPtr ptr = Runtime.Py_CompileString(code, filename, flag);
|
||||
Runtime.CheckExceptionOccurred();
|
||||
return new PyObject(ptr);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Eval Method
|
||||
|
|
@ -539,6 +547,18 @@ namespace Python.Runtime
|
|||
return new GILState();
|
||||
}
|
||||
|
||||
public static PyScope CreateScope()
|
||||
{
|
||||
var scope = PyScopeManager.Global.Create();
|
||||
return scope;
|
||||
}
|
||||
|
||||
public static PyScope CreateScope(string name)
|
||||
{
|
||||
var scope = PyScopeManager.Global.Create(name);
|
||||
return scope;
|
||||
}
|
||||
|
||||
public class GILState : IDisposable
|
||||
{
|
||||
private IntPtr state;
|
||||
|
|
|
|||
|
|
@ -707,6 +707,9 @@ namespace Python.Runtime
|
|||
[DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
|
||||
internal static extern IntPtr PyRun_String(string code, IntPtr st, IntPtr globals, IntPtr locals);
|
||||
|
||||
[DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
|
||||
internal static extern IntPtr PyEval_EvalCode(IntPtr co, IntPtr globals, IntPtr locals);
|
||||
|
||||
[DllImport(PythonDll, CallingConvention = CallingConvention.Cdecl)]
|
||||
internal static extern IntPtr Py_CompileString(string code, string file, IntPtr tok);
|
||||
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче