pothos: work on proxy as universally supported in case of failure

guruofquality · guruofquality · commit 3fe859d02b7a · 2014-06-07T00:53:46.000-04:00
diff --git a/Pothos/Block.py b/Pothos/Block.py
@@ -12,7 +12,7 @@ def __init__(self):
         env = ProxyEnvironment("managed")
         reg = env.findProxy("Pothos/BlockRegistry")
         self._block = reg.callProxy("/blocks/python/python_block")
-        self._block._setPyBlock(Proxy(Proxy(weakref.proxy(self))))
+        self._block._setPyBlock(weakref.proxy(self))
 
     def __getattr__(self, name):
         return lambda *args: self._block.call(name, *args)
diff --git a/Pothos/Converters.cpp b/Pothos/Converters.cpp
@@ -7,12 +7,6 @@
 /***********************************************************************
  * Proxy conversions
  **********************************************************************/
-static Pothos::Proxy convertProxyToPyProxy(Pothos::ProxyEnvironment::Sptr, const Pothos::Proxy &proxy)
-{
-    PyObjectRef ref(makeProxyObject(proxy), REF_NEW);
-    return PyObjectToProxy(ref.obj);
-}
-
 static Pothos::Proxy convertPyProxyToProxy(const Pothos::Proxy &proxy)
 {
     PyObjectRef ref(ProxyToPyObject(proxy), REF_NEW);
diff --git a/Pothos/PothosModule.cpp b/Pothos/PothosModule.cpp
@@ -33,10 +33,18 @@ static void initPyObjectUtilityConverters(void)
 Pothos::Proxy PyObjectToProxy(PyObject *obj)
 {
     assert(obj != nullptr);
+    if (isProxyObject(obj)) return *reinterpret_cast<ProxyObject *>(obj)->proxy;
     PyThreadStateLock lock;
     return myPyObjectToProxyFcn(myPythonProxyEnv, obj);
 }
 
+Pothos::Proxy convertProxyToPyProxy(Pothos::ProxyEnvironment::Sptr env, const Pothos::Proxy &proxy)
+{
+    PyObjectRef ref(makeProxyObject(proxy), REF_NEW);
+    PyThreadStateLock lock;
+    return myPyObjectToProxyFcn(env, ref.obj);
+}
+
 PyObject *ProxyToPyObject(const Pothos::Proxy &proxy)
 {
     assert(proxy);
diff --git a/Pothos/PothosModule.hpp b/Pothos/PothosModule.hpp
@@ -59,13 +59,8 @@ PyObject *makeProxyObject(const Pothos::Proxy &proxy);
 //! utility for c api to check if a proxy
 bool isProxyObject(PyObject *obj);
 
-//! Unwrap an already proxied object -- otherwise call PyObjectToProxy()
-inline Pothos::Proxy PyObjectToProxyInspect(PyObject *obj)
-{
-    assert(obj != nullptr);
-    if (isProxyObject(obj)) return *reinterpret_cast<ProxyObject *>(obj)->proxy;
-    return PyObjectToProxy(obj);
-}
+//! TODO only exposed for converters
+Pothos::Proxy convertProxyToPyProxy(Pothos::ProxyEnvironment::Sptr env, const Pothos::Proxy &proxy);
 
 /***********************************************************************
  * Pothos::ProxyCall support
diff --git a/Pothos/ProxyCallType.cpp b/Pothos/ProxyCallType.cpp
@@ -33,7 +33,7 @@ PyObject* ProxyCall_call(ProxyCallObject *self, PyObject *args, PyObject *)
         Pothos::ProxyVector proxyArgs;
         for (int i = 0; i < PyTuple_Size(args); i++)
         {
-            proxyArgs.push_back(PyObjectToProxyInspect(PyTuple_GetItem(args, i)));
+            proxyArgs.push_back(PyObjectToProxy(PyTuple_GetItem(args, i)));
         }
 
         //make proxy call
diff --git a/Pothos/ProxyType.cpp b/Pothos/ProxyType.cpp
@@ -81,7 +81,7 @@ int Proxy_setattr(PyObject *self, PyObject *attr_name, PyObject *v)
 
         //convert args
         Pothos::ProxyVector proxyArgs;
-        proxyArgs.push_back(PyObjectToProxyInspect(v));
+        proxyArgs.push_back(PyObjectToProxy(v));
 
         auto handle = reinterpret_cast<ProxyObject *>(self)->proxy->getHandle();
         Pothos::Proxy proxy;
@@ -124,7 +124,7 @@ static Pothos::Proxy Proxy_callProxyHelper(ProxyObject *self, PyObject *args)
     const auto name = PyObjectToProxy(PyTuple_GetItem(args, 0)).convert<std::string>();
     for (int i = 1; i < PyTuple_Size(args); i++)
     {
-        proxyArgs.push_back(PyObjectToProxyInspect(PyTuple_GetItem(args, i)));
+        proxyArgs.push_back(PyObjectToProxy(PyTuple_GetItem(args, i)));
     }
 
     PyThreadStateLock lock; //proxy call could be potentially blocking
@@ -203,7 +203,7 @@ PyObject* Proxy_Compare(PyObject *o1, PyObject *o2, int opid)
 {
     try
     {
-        const int cmp = PyObjectToProxyInspect(o1).compareTo(PyObjectToProxyInspect(o2));
+        const int cmp = PyObjectToProxy(o1).compareTo(PyObjectToProxy(o2));
         return richCompareFromSimple(cmp, opid);
     }
     catch (const Pothos::Exception &ex)
diff --git a/ProxyHelpers.cpp b/ProxyHelpers.cpp
@@ -3,6 +3,7 @@
 
 #include "PythonProxy.hpp"
 #include <Pothos/Plugin.hpp>
+#include <cassert>
 
 /***********************************************************************
  * PyObject helpers - used in python bindings
@@ -14,6 +15,8 @@ static Pothos::Proxy convertPyObjectToProxy(Pothos::ProxyEnvironment::Sptr env,
 
 static PyObject *convertProxyToPyObject(const Pothos::Proxy &proxy)
 {
+    assert(proxy);
+    assert(std::dynamic_pointer_cast<PythonProxyHandle>(proxy.getHandle()));
     return std::dynamic_pointer_cast<PythonProxyHandle>(proxy.getHandle())->ref.newRef();
 }
 
diff --git a/PythonHandle.cpp b/PythonHandle.cpp
@@ -7,9 +7,10 @@
 #include "PythonProxy.hpp"
 
 PythonProxyHandle::PythonProxyHandle(std::shared_ptr<PythonProxyEnvironment> env, PyObject *obj, const bool borrowed):
-    env(env), obj(obj), ref(PyObjectRef(obj, borrowed))
+    env(env), obj(obj)
 {
-    return;
+    PyGilStateLock lock;
+    ref = PyObjectRef(obj, borrowed);
 }
 
 PythonProxyHandle::~PythonProxyHandle(void)
@@ -143,5 +144,7 @@ Pothos::Proxy PythonProxyHandle::call(const std::string &name, const Pothos::Pro
         throw Pothos::ProxyExceptionMessage(errorMsg);
     }
 
-    return env->makeHandle(result);
+    auto x = env->makeHandle(result);
+    if (x.getClassName() == "PothosProxy") return x.convert<Pothos::Proxy>();
+    return x;
 }
diff --git a/PythonProxy.cpp b/PythonProxy.cpp
@@ -45,14 +45,12 @@ PythonProxyEnvironment::PythonProxyEnvironment(const Pothos::ProxyEnvironmentArg
 
 Pothos::Proxy PythonProxyEnvironment::makeHandle(PyObject *obj, const bool borrowed)
 {
-    PyGilStateLock lock;
     auto env = std::dynamic_pointer_cast<PythonProxyEnvironment>(this->shared_from_this());
     return Pothos::Proxy(new PythonProxyHandle(env, obj, borrowed));
 }
 
 Pothos::Proxy PythonProxyEnvironment::makeHandle(const PyObjectRef &ref)
 {
-    PyGilStateLock lock;
     return this->makeHandle(ref.obj, REF_BORROWED);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,18 @@ static void initPyObjectUtilityConverters(void)`
`33`	`33`	`Pothos::Proxy PyObjectToProxy(PyObject *obj)`
`34`	`34`	`{`
`35`	`35`	`assert(obj != nullptr);`
	`36`	`+ if (isProxyObject(obj)) return reinterpret_cast<ProxyObject >(obj)->proxy;`
`36`	`37`	`PyThreadStateLock lock;`
`37`	`38`	`return myPyObjectToProxyFcn(myPythonProxyEnv, obj);`
`38`	`39`	`}`
`39`	`40`
	`41`	`+Pothos::Proxy convertProxyToPyProxy(Pothos::ProxyEnvironment::Sptr env, const Pothos::Proxy &proxy)`
	`42`	`+{`
	`43`	`+ PyObjectRef ref(makeProxyObject(proxy), REF_NEW);`
	`44`	`+ PyThreadStateLock lock;`
	`45`	`+ return myPyObjectToProxyFcn(env, ref.obj);`
	`46`	`+}`
	`47`	`+`
`40`	`48`	`PyObject *ProxyToPyObject(const Pothos::Proxy &proxy)`
`41`	`49`	`{`
`42`	`50`	`assert(proxy);`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ PyObject* ProxyCall_call(ProxyCallObject self, PyObject args, PyObject *)`
`33`	`33`	`Pothos::ProxyVector proxyArgs;`
`34`	`34`	`for (int i = 0; i < PyTuple_Size(args); i++)`
`35`	`35`	`{`
`36`		`- proxyArgs.push_back(PyObjectToProxyInspect(PyTuple_GetItem(args, i)));`
	`36`	`+ proxyArgs.push_back(PyObjectToProxy(PyTuple_GetItem(args, i)));`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`//make proxy call`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ int Proxy_setattr(PyObject self, PyObject attr_name, PyObject *v)`
`81`	`81`
`82`	`82`	`//convert args`
`83`	`83`	`Pothos::ProxyVector proxyArgs;`
`84`		`- proxyArgs.push_back(PyObjectToProxyInspect(v));`
	`84`	`+ proxyArgs.push_back(PyObjectToProxy(v));`
`85`	`85`
`86`	`86`	`auto handle = reinterpret_cast<ProxyObject *>(self)->proxy->getHandle();`
`87`	`87`	`Pothos::Proxy proxy;`
`@@ -124,7 +124,7 @@ static Pothos::Proxy Proxy_callProxyHelper(ProxyObject self, PyObject args)`
`124`	`124`	`const auto name = PyObjectToProxy(PyTuple_GetItem(args, 0)).convert<std::string>();`
`125`	`125`	`for (int i = 1; i < PyTuple_Size(args); i++)`
`126`	`126`	`{`
`127`		`- proxyArgs.push_back(PyObjectToProxyInspect(PyTuple_GetItem(args, i)));`
	`127`	`+ proxyArgs.push_back(PyObjectToProxy(PyTuple_GetItem(args, i)));`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`PyThreadStateLock lock; //proxy call could be potentially blocking`
`@@ -203,7 +203,7 @@ PyObject* Proxy_Compare(PyObject o1, PyObject o2, int opid)`
`203`	`203`	`{`
`204`	`204`	`try`
`205`	`205`	`{`
`206`		`- const int cmp = PyObjectToProxyInspect(o1).compareTo(PyObjectToProxyInspect(o2));`
	`206`	`+ const int cmp = PyObjectToProxy(o1).compareTo(PyObjectToProxy(o2));`
`207`	`207`	`return richCompareFromSimple(cmp, opid);`
`208`	`208`	`}`
`209`	`209`	`catch (const Pothos::Exception &ex)`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`#include "PythonProxy.hpp"`
`5`	`5`	`#include <Pothos/Plugin.hpp>`
	`6`	`+#include <cassert>`
`6`	`7`
`7`	`8`	`/***********************************************************************`
`8`	`9`	`* PyObject helpers - used in python bindings`
`@@ -14,6 +15,8 @@ static Pothos::Proxy convertPyObjectToProxy(Pothos::ProxyEnvironment::Sptr env,`
`14`	`15`
`15`	`16`	`static PyObject *convertProxyToPyObject(const Pothos::Proxy &proxy)`
`16`	`17`	`{`
	`18`	`+ assert(proxy);`
	`19`	`+ assert(std::dynamic_pointer_cast<PythonProxyHandle>(proxy.getHandle()));`
`17`	`20`	`return std::dynamic_pointer_cast<PythonProxyHandle>(proxy.getHandle())->ref.newRef();`
`18`	`21`	`}`
`19`	`22`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,10 @@`
`7`	`7`	`#include "PythonProxy.hpp"`
`8`	`8`
`9`	`9`	`PythonProxyHandle::PythonProxyHandle(std::shared_ptr<PythonProxyEnvironment> env, PyObject *obj, const bool borrowed):`
`10`		`- env(env), obj(obj), ref(PyObjectRef(obj, borrowed))`
	`10`	`+ env(env), obj(obj)`
`11`	`11`	`{`
`12`		`- return;`
	`12`	`+ PyGilStateLock lock;`
	`13`	`+ ref = PyObjectRef(obj, borrowed);`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`PythonProxyHandle::~PythonProxyHandle(void)`
`@@ -143,5 +144,7 @@ Pothos::Proxy PythonProxyHandle::call(const std::string &name, const Pothos::Pro`
`143`	`144`	`throw Pothos::ProxyExceptionMessage(errorMsg);`
`144`	`145`	`}`
`145`	`146`
`146`		`- return env->makeHandle(result);`
	`147`	`+ auto x = env->makeHandle(result);`
	`148`	`+ if (x.getClassName() == "PothosProxy") return x.convert<Pothos::Proxy>();`
	`149`	`+ return x;`
`147`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,14 +45,12 @@ PythonProxyEnvironment::PythonProxyEnvironment(const Pothos::ProxyEnvironmentArg`
`45`	`45`
`46`	`46`	`Pothos::Proxy PythonProxyEnvironment::makeHandle(PyObject *obj, const bool borrowed)`
`47`	`47`	`{`
`48`		`- PyGilStateLock lock;`
`49`	`48`	`auto env = std::dynamic_pointer_cast<PythonProxyEnvironment>(this->shared_from_this());`
`50`	`49`	`return Pothos::Proxy(new PythonProxyHandle(env, obj, borrowed));`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`Pothos::Proxy PythonProxyEnvironment::makeHandle(const PyObjectRef &ref)`
`54`	`53`	`{`
`55`		`- PyGilStateLock lock;`
`56`	`54`	`return this->makeHandle(ref.obj, REF_BORROWED);`
`57`	`55`	`}`
`58`	`56`