1 // Copyright (C) 2006-2023 CEA, EDF
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include "RuntimeSALOME.hxx"
21 #include "PythonNode.hxx"
22 #include "PythonPorts.hxx"
23 #include "TypeCode.hxx"
24 #include "PythonCppUtils.hxx"
25 #include "Container.hxx"
26 #include "SalomeContainer.hxx"
27 #include "SalomeHPContainer.hxx"
28 #include "SalomeContainerTmpForHP.hxx"
29 #include "ConversionException.hxx"
30 #include "ReceiverFactory.hxx"
31 #include "SenderByteImpl.hxx"
33 #include "PyStdout.hxx"
41 #define getpid _getpid
44 #if PY_VERSION_HEX < 0x02050000
45 typedef int Py_ssize_t;
49 #include "YacsTrace.hxx"
51 using namespace YACS::ENGINE;
54 const char PythonEntry::SCRIPT_FOR_SIMPLE_SERIALIZATION[]="import pickle\n"
55 "def pickleForVarSimplePyth2009(val):\n"
56 " return pickle.dumps(val,-1)\n"
59 PyObject *PythonEntry::_pyClsBigObject = nullptr;
61 const char PythonNode::IMPL_NAME[]="Python";
62 const char PythonNode::KIND[]="Python";
64 const char PythonNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
65 "def pickleForDistPyth2009(kws):\n"
66 " return pickle.dumps(((),kws),-1)\n"
68 "def unPickleForDistPyth2009(st):\n"
69 " args=pickle.loads(st)\n"
72 const char PythonNode::REMOTE_NAME[]="remote";
74 const char PythonNode::DPL_INFO_NAME[]="my_dpl_localization";
76 const char PyFuncNode::SCRIPT_FOR_SERIALIZATION[]="import pickle\n"
77 "def pickleForDistPyth2009(*args,**kws):\n"
78 " return pickle.dumps((args,kws),-1)\n"
80 "def unPickleForDistPyth2009(st):\n"
81 " args=pickle.loads(st)\n"
84 static char SCRIPT_FOR_BIGOBJECT[]="import SALOME_PyNode\n"
85 "BigObjectOnDiskBase = SALOME_PyNode.BigObjectOnDiskBase\n";
87 // pickle.load concurrency issue : see https://bugs.python.org/issue12680
88 #if PY_VERSION_HEX < 0x03070000
90 static std::mutex data_mutex;
93 PythonEntry::PythonEntry():_context(0),_pyfuncSer(0),_pyfuncUnser(0),_pyfuncSimpleSer(0)
97 PythonEntry::~PythonEntry()
100 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
101 // not Py_XDECREF of _pyfuncUnser because it is returned by PyDict_GetItem -> borrowed
102 // not Py_XDECREF of _pyfuncSer because it is returned by PyDict_GetItem -> borrowed
103 Py_XDECREF(_context);
106 void PythonEntry::loadRemoteContainer(InlineNode *reqNode)
108 DEBTRACE( "---------------PythonEntry::CommonRemoteLoad function---------------" );
109 Container *container(reqNode->getContainer());
110 bool isContAlreadyStarted(false);
115 if(hasImposedResource())
116 container->start(reqNode, _imposedResource, _imposedContainer);
119 isContAlreadyStarted=container->isAlreadyStarted(reqNode);
120 if(!isContAlreadyStarted)
121 container->start(reqNode);
126 reqNode->setErrorDetails(e.what());
132 std::string what("PythonEntry::CommonRemoteLoad : a load operation requested on \"");
133 what+=reqNode->getName(); what+="\" with no container specified.";
134 reqNode->setErrorDetails(what);
135 throw Exception(what);
139 Engines::Container_var GetContainerObj(InlineNode *reqNode, bool& isStandardCont)
141 isStandardCont = false;
142 Container *container(reqNode->getContainer());
143 Engines::Container_var objContainer(Engines::Container::_nil());
145 throw YACS::Exception("No container specified !");
146 SalomeContainer *containerCast0(dynamic_cast<SalomeContainer *>(container));
147 SalomeHPContainer *containerCast1(dynamic_cast<SalomeHPContainer *>(container));
150 isStandardCont = true;
151 objContainer=containerCast0->getContainerPtr(reqNode);
153 else if(containerCast1)
155 YACS::BASES::AutoCppPtr<SalomeContainerTmpForHP> tmpCont(SalomeContainerTmpForHP::BuildFrom(containerCast1,reqNode));
156 objContainer=tmpCont->getContainerPtr(reqNode);
159 throw YACS::Exception("Unrecognized type of container ! Salome one is expected for PythonNode/PyFuncNode !");
160 if(CORBA::is_nil(objContainer))
161 throw YACS::Exception("Container corba pointer is NULL for PythonNode !");
165 Engines::Container_var PythonEntry::loadPythonAdapter(InlineNode *reqNode, bool& isInitializeRequested)
167 bool isStandardCont(true);
168 Engines::Container_var objContainer(GetContainerObj(reqNode,isStandardCont));
169 isInitializeRequested=false;
172 Engines::PyNodeBase_var dftPyScript(retrieveDftRemotePyInterpretorIfAny(objContainer));
173 if(CORBA::is_nil(dftPyScript))
175 isInitializeRequested=!isStandardCont;
176 createRemoteAdaptedPyInterpretor(objContainer);
179 assignRemotePyInterpretor(dftPyScript);
181 catch( const SALOME::SALOME_Exception& ex )
183 std::string msg="Exception on remote python node creation ";
185 msg += ex.details.text.in();
186 reqNode->setErrorDetails(msg);
187 throw Exception(msg);
189 Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
190 if(CORBA::is_nil(pynode))
191 throw Exception("In PythonNode the ref in NULL ! ");
195 void PythonEntry::loadRemoteContext(InlineNode *reqNode, Engines::Container_ptr objContainer, bool isInitializeRequested)
197 Container *container(reqNode->getContainer());
198 Engines::PyNodeBase_var pynode(getRemoteInterpreterHandle());
201 #if PY_VERSION_HEX < 0x03070000
202 std::unique_lock<std::mutex> lock(data_mutex);
205 const char *picklizeScript(getSerializationScript());
206 PyObject *res=PyRun_String(picklizeScript,Py_file_input,_context,_context);
207 PyObject *res2(PyRun_String(SCRIPT_FOR_SIMPLE_SERIALIZATION,Py_file_input,_context,_context));
208 if(res == NULL || res2==NULL)
210 std::string errorDetails;
211 PyObject* new_stderr = newPyStdOut(errorDetails);
212 reqNode->setErrorDetails(errorDetails);
213 PySys_SetObject((char*)"stderr", new_stderr);
215 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
216 Py_DECREF(new_stderr);
217 throw Exception("Error during load");
219 Py_DECREF(res); Py_DECREF(res2);
220 AutoPyRef res3(PyRun_String(SCRIPT_FOR_BIGOBJECT,Py_file_input,_context,_context));
221 _pyfuncSer=PyDict_GetItemString(_context,"pickleForDistPyth2009");
222 _pyfuncUnser=PyDict_GetItemString(_context,"unPickleForDistPyth2009");
223 _pyfuncSimpleSer=PyDict_GetItemString(_context,"pickleForVarSimplePyth2009");
224 if(! _pyClsBigObject )
226 _pyClsBigObject=PyDict_GetItemString(_context,"BigObjectOnDiskBase");
227 Py_INCREF(_pyClsBigObject);
229 if(_pyfuncSer == NULL)
231 std::string errorDetails;
232 PyObject *new_stderr(newPyStdOut(errorDetails));
233 reqNode->setErrorDetails(errorDetails);
234 PySys_SetObject((char*)"stderr", new_stderr);
236 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
237 Py_DECREF(new_stderr);
238 throw Exception("Error during load");
240 if(_pyfuncUnser == NULL)
242 std::string errorDetails;
243 PyObject *new_stderr(newPyStdOut(errorDetails));
244 reqNode->setErrorDetails(errorDetails);
245 PySys_SetObject((char*)"stderr", new_stderr);
247 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
248 Py_DECREF(new_stderr);
249 throw Exception("Error during load");
251 if(_pyfuncSimpleSer == NULL)
253 std::string errorDetails;
254 PyObject *new_stderr(newPyStdOut(errorDetails));
255 reqNode->setErrorDetails(errorDetails);
256 PySys_SetObject((char*)"stderr", new_stderr);
258 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
259 Py_DECREF(new_stderr);
260 throw Exception("Error during load");
263 if(isInitializeRequested)
264 {//This one is called only once at initialization in the container if an init-script is specified.
267 std::string zeInitScriptKey(container->getProperty(HomogeneousPoolContainer::INITIALIZE_SCRIPT_KEY));
268 if(!zeInitScriptKey.empty())
269 pynode->executeAnotherPieceOfCode(zeInitScriptKey.c_str());
271 catch( const SALOME::SALOME_Exception& ex )
273 std::string msg="Exception on PythonNode::loadRemote python invocation of initializisation py script !";
275 msg += ex.details.text.in();
276 reqNode->setErrorDetails(msg);
277 throw Exception(msg);
279 DEBTRACE( "---------------End PyNode::loadRemote function---------------" );
283 std::string PythonEntry::GetContainerLog(const std::string& mode, Container *container, const Task *askingTask)
291 SalomeContainer *containerCast(dynamic_cast<SalomeContainer *>(container));
292 SalomeHPContainer *objContainer2(dynamic_cast<SalomeHPContainer *>(container));
295 Engines::Container_var objContainer(containerCast->getContainerPtr(askingTask));
296 CORBA::String_var logname = objContainer->logfilename();
299 std::string::size_type pos = msg.find(":");
300 msg=msg.substr(pos+1);
302 else if(objContainer2)
304 msg="Remote PythonNode is on HP Container : no log because no info of the location by definition of HP Container !";
308 msg="Not implemented yet for container log for that type of container !";
313 msg = "Container no longer reachable";
318 void PythonEntry::commonRemoteLoad(InlineNode *reqNode)
320 loadRemoteContainer(reqNode);
321 bool isInitializeRequested;
322 Engines::Container_var objContainer(loadPythonAdapter(reqNode,isInitializeRequested));
323 loadRemoteContext(reqNode,objContainer,isInitializeRequested);
326 bool PythonEntry::hasImposedResource()const
328 return !_imposedResource.empty() && !_imposedContainer.empty();
331 bool PythonEntry::IsProxy( PyObject *ob )
335 return PyObject_IsInstance( ob, _pyClsBigObject) == 1;
338 bool PythonEntry::GetDestroyStatus( PyObject *ob )
342 if( PyObject_IsInstance( ob, _pyClsBigObject) == 1 )
344 AutoPyRef unlinkOnDestructor = PyObject_GetAttrString(ob,"getDestroyStatus");
345 AutoPyRef tmp = PyObject_CallFunctionObjArgs(unlinkOnDestructor,nullptr);
346 if( PyBool_Check(tmp.get()) )
348 return tmp.get() == Py_True;
355 void PythonEntry::IfProxyDoSomething( PyObject *ob, const char *meth )
359 if( PyObject_IsInstance( ob, _pyClsBigObject) == 1 )
361 AutoPyRef unlinkOnDestructor = PyObject_GetAttrString(ob,meth);
362 AutoPyRef tmp = PyObject_CallFunctionObjArgs(unlinkOnDestructor,nullptr);
366 void PythonEntry::DoNotTouchFileIfProxy( PyObject *ob )
368 IfProxyDoSomething(ob,"doNotTouchFile");
371 void PythonEntry::UnlinkOnDestructorIfProxy( PyObject *ob )
373 IfProxyDoSomething(ob,"unlinkOnDestructor");
376 PythonNode::PythonNode(const PythonNode& other, ComposedNode *father):InlineNode(other,father),_autoSqueeze(other._autoSqueeze)
378 _pynode = Engines::PyScriptNode::_nil();
379 _implementation=IMPL_NAME;
382 _context=PyDict_New();
383 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
386 msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
387 _errorDetails=msg.str();
388 throw Exception(msg.str());
393 PythonNode::PythonNode(const std::string& name):InlineNode(name)
395 _pynode = Engines::PyScriptNode::_nil();
396 _implementation=IMPL_NAME;
399 _context=PyDict_New();
400 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
403 msg << "Impossible to set builtins" << __FILE__ << ":" << __LINE__;
404 _errorDetails=msg.str();
405 throw Exception(msg.str());
410 PythonNode::~PythonNode()
415 void PythonNode::checkBasicConsistency() const
417 DEBTRACE("checkBasicConsistency");
418 InlineNode::checkBasicConsistency();
422 res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
425 std::string error="";
426 PyObject* new_stderr = newPyStdOut(error);
427 PySys_SetObject((char*)"stderr", new_stderr);
429 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
430 Py_DECREF(new_stderr);
431 throw Exception(error);
438 void PythonNode::load()
440 DEBTRACE( "---------------PyNode::load function---------------" );
441 if(_mode==PythonNode::REMOTE_NAME)
447 void PythonNode::loadLocal()
449 DEBTRACE( "---------------PyNode::loadLocal function---------------" );
453 void PythonNode::loadRemote()
455 commonRemoteLoad(this);
458 void PythonNode::execute()
460 if(_mode==PythonNode::REMOTE_NAME)
466 void PythonNode::executeRemote()
468 DEBTRACE( "++++++++++++++ PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
470 throw Exception("PythonNode badly loaded");
472 if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
475 loadPythonAdapter(this,dummy);
476 _pynode->assignNewCompiledCode(getScript().c_str());
478 // not managed by unique_ptr here because destructed by the order of client.
479 SenderByteImpl *serializationInputCorba = nullptr;
480 AutoPyRef serializationInput;
482 #if PY_VERSION_HEX < 0x03070000
483 std::unique_lock<std::mutex> lock(data_mutex);
486 PyObject *args(0),*ob(0);
487 //===========================================================================
488 // Get inputs in input ports, build a Python dict and pickle it
489 //===========================================================================
491 std::list<InputPort *>::iterator iter2;
493 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); ++iter2)
495 InputPyPort *p=(InputPyPort *)*iter2;
497 PyDict_SetItemString(args,p->getName().c_str(),ob);
501 PyObject_Print(args,stderr,Py_PRINT_RAW);
504 serializationInput.set(PyObject_CallFunctionObjArgs(_pyfuncSer,args,nullptr));
506 //The pickled string may contain NULL characters so use PyString_AsStringAndSize
507 char *serializationInputC(nullptr);
509 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
510 throw Exception("DistributedPythonNode problem in python pickle");
511 // no copy here. The C byte array of Python is taken as this into CORBA sequence to avoid copy
512 serializationInputCorba = new SenderByteImpl(serializationInputC,len);
515 //get the list of output argument names
516 std::list<OutputPort *>::iterator iter;
517 Engines::listofstring myseq;
518 myseq.length(getNumberOfOutputPorts());
520 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
522 OutputPyPort *p=(OutputPyPort *)*iter;
523 myseq[pos]=p->getName().c_str();
524 DEBTRACE( "port name: " << p->getName() );
525 DEBTRACE( "port kind: " << p->edGetType()->kind() );
526 DEBTRACE( "port pos : " << pos );
529 //===========================================================================
530 // Execute in remote Python node
531 //===========================================================================
532 DEBTRACE( "-----------------starting remote python invocation-----------------" );
533 std::unique_ptr<SALOME::SenderByteSeq> resultCorba;
536 //pass outargsname and dict serialized
537 SALOME::SenderByte_var serializationInputRef = serializationInputCorba->_this();
538 _pynode->executeFirst(serializationInputRef);
539 //serializationInput and serializationInputCorba are no more needed for server. Release it.
540 serializationInput.set(nullptr);
541 resultCorba.reset( _pynode->executeSecond(myseq) );
542 if( ! this->isUsingPythonCache() )
543 _pynode->removeAllVarsInContext();
545 catch( const SALOME::SALOME_Exception& ex )
547 std::ostringstream msg; msg << "Exception on remote python invocation" << std::endl << ex.details.text.in() << std::endl;
548 msg << "PyScriptNode CORBA ref : ";
550 CORBA::ORB_ptr orb(getSALOMERuntime()->getOrb());
551 if(!CORBA::is_nil(orb))
553 CORBA::String_var IOR(orb->object_to_string(_pynode));
558 _errorDetails=msg.str();
559 throw Exception(msg.str());
561 catch(CORBA::COMM_FAILURE& ex)
563 std::ostringstream msg;
564 msg << "Exception on remote python invocation." << std::endl ;
565 msg << "Caught system exception COMM_FAILURE -- unable to contact the "
566 << "object." << std::endl;
567 _errorDetails=msg.str();
568 throw Exception(msg.str());
570 catch(CORBA::SystemException& ex)
572 std::ostringstream msg;
573 msg << "Exception on remote python invocation." << std::endl ;
574 msg << "Caught a CORBA::SystemException." ;
577 CORBA::TypeCode_var tc = tmp.type();
578 const char *p = tc->name();
584 _errorDetails=msg.str();
585 throw Exception(msg.str());
587 catch(CORBA::Exception& ex)
589 std::ostringstream msg;
590 msg << "Exception on remote python invocation." << std::endl ;
591 msg << "Caught CORBA::Exception. " ;
594 CORBA::TypeCode_var tc = tmp.type();
595 const char *p = tc->name();
601 _errorDetails=msg.str();
602 throw Exception(msg.str());
604 catch(omniORB::fatalException& fe)
606 std::ostringstream msg;
607 msg << "Exception on remote python invocation." << std::endl ;
608 msg << "Caught omniORB::fatalException:" << std::endl;
609 msg << " file: " << fe.file() << std::endl;
610 msg << " line: " << fe.line() << std::endl;
611 msg << " mesg: " << fe.errmsg() << std::endl;
612 _errorDetails=msg.str();
613 throw Exception(msg.str());
615 DEBTRACE( "-----------------end of remote python invocation-----------------" );
616 //===========================================================================
617 // Get results, unpickle and put them in output ports
618 //===========================================================================
620 #if PY_VERSION_HEX < 0x03070000
621 std::unique_lock<std::mutex> lock(data_mutex);
624 DEBTRACE( "-----------------PythonNode::outputs-----------------" );
625 int nres( resultCorba->length() );
627 if(getNumberOfOutputPorts() != nres)
629 std::string msg="Number of output arguments : Mismatch between definition and execution";
631 throw Exception(msg);
636 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); ++iter)
638 OutputPyPort *p=(OutputPyPort *)*iter;
639 DEBTRACE( "port name: " << p->getName() );
640 DEBTRACE( "port kind: " << p->edGetType()->kind() );
641 DEBTRACE( "port pos : " << pos );
642 SALOME::SenderByte_var elt = (*resultCorba)[pos];
643 SeqByteReceiver recv(elt);
644 unsigned long length = 0;
645 char *resultCorbaC = recv.data(length);
647 AutoPyRef resultPython=PyMemoryView_FromMemory(resultCorbaC,length,PyBUF_READ);
648 AutoPyRef args = PyTuple_New(1);
649 PyTuple_SetItem(args,0,resultPython.retn());
650 AutoPyRef ob = PyObject_CallObject(_pyfuncUnser,args);
653 std::stringstream msg;
654 msg << "Conversion with pickle of output ports failed !";
655 msg << " : " << __FILE__ << ":" << __LINE__;
656 _errorDetails=msg.str();
657 throw YACS::ENGINE::ConversionException(msg.str());
659 UnlinkOnDestructorIfProxy(ob);
665 catch(ConversionException& ex)
667 _errorDetails=ex.what();
671 squeezeMemoryRemote();
674 if(!isUsingPythonCache())
678 Engines::Container_var cont(GetContainerObj(this,dummy));
679 cont->removePyScriptNode(getName().c_str());
681 DEBTRACE( "++++++++++++++ ENDOF PyNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
683 void PythonNode::executeLocalInternal(const std::string& codeStr)
686 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
687 std::ostringstream stream;
688 stream << "/tmp/PythonNode_";
690 AutoPyRef code=Py_CompileString(codeStr.c_str(), stream.str().c_str(), Py_file_input);
694 AutoPyRef new_stderr = newPyStdOut(_errorDetails);
695 PySys_SetObject((char*)"stderr", new_stderr);
697 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
698 throw Exception("Error during execution");
701 AutoPyRef res = PyEval_EvalCode( code, _context, _context);
703 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
706 if(PyErr_Occurred ())
709 AutoPyRef new_stderr = newPyStdOut(_errorDetails);
710 PySys_SetObject((char*)"stderr", new_stderr);
711 ofstream errorfile(stream.str().c_str());
712 if (errorfile.is_open())
714 errorfile << codeStr;
718 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
719 throw Exception("Error during execution");
723 void PythonNode::executeLocal()
725 DEBTRACE( "++++++++++++++ PyNode::executeLocal: " << getName() << " ++++++++++++++++++++" );
728 std::ostringstream unpxy; unpxy << "from SALOME_PyNode import UnProxyObjectSimpleLocal" << std::endl;
729 DEBTRACE( "---------------PyNode::inputs---------------" );
730 list<InputPort *>::iterator iter2;
731 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
733 InputPyPort *p=(InputPyPort *)*iter2;
734 DEBTRACE( "port name: " << p->getName() );
735 DEBTRACE( "port kind: " << p->edGetType()->kind() );
736 PyObject* ob=p->getPyObj();
737 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
738 unpxy << p->getName() << " = UnProxyObjectSimpleLocal( " << p->getName() << " )" << std::endl;
740 PyObject_Print(ob,stderr,Py_PRINT_RAW);
743 int ier=PyDict_SetItemString(_context,p->getName().c_str(),ob);
744 DEBTRACE( "after PyDict_SetItemString:ob refcnt: " << ob->ob_refcnt );
747 DEBTRACE( "---------------End PyNode::inputs---------------" );
750 DEBTRACE( "----------------PyNode::calculation---------------" );
752 executeLocalInternal( unpxy.str() );
754 executeLocalInternal( _script );
756 DEBTRACE( "-----------------PyNode::outputs-----------------" );
757 list<OutputPort *>::iterator iter;
760 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
762 OutputPyPort *p=(OutputPyPort *)*iter;
763 DEBTRACE( "port name: " << p->getName() );
764 DEBTRACE( "port kind: " << p->edGetType()->kind() );
765 PyObject *ob=PyDict_GetItemString(_context,p->getName().c_str());
768 std::string msg="Error during execution: there is no variable ";
769 msg=msg+p->getName()+" in node context";
771 throw Exception(msg);
773 DEBTRACE( "PyNode::outputs::ob refcnt: " << ob->ob_refcnt );
775 PyObject_Print(ob,stderr,Py_PRINT_RAW);
781 catch(ConversionException& ex)
783 _errorDetails=ex.what();
788 DEBTRACE( "-----------------End PyNode::outputs-----------------" );
790 DEBTRACE( "++++++++++++++ End PyNode::execute: " << getName() << " ++++++++++++++++++++" );
793 void PythonNode::squeezeMemorySafe()
796 if(_mode==PythonNode::REMOTE_NAME)
797 this->squeezeMemoryRemote();
799 this->squeezeMemory();
802 void PythonNode::squeezeMemory()
804 for(auto p : _setOfInputPort)
806 PyDict_DelItemString(_context,p->getName().c_str());
807 InputPyPort *p2(static_cast<InputPyPort *>(p));
808 if(p2->canSafelySqueezeMemory())
811 for(auto p : _setOfOutputPort)
813 PyDict_DelItemString(_context,p->getName().c_str());
814 OutputPyPort *p2(static_cast<OutputPyPort *>(p));
815 p2->putWithoutForward(Py_None);
819 void PythonNode::squeezeMemoryRemote()
821 for(auto p : _setOfInputPort)
823 InputPyPort *p2(static_cast<InputPyPort *>(p));
824 if(p2->canSafelySqueezeMemory())
827 for(auto p : _setOfOutputPort)
829 OutputPyPort *p2(static_cast<OutputPyPort *>(p));
830 p2->putWithoutForward(Py_None);
834 std::string PythonNode::getContainerLog()
836 return PythonEntry::GetContainerLog(_mode,_container,this);
839 void PythonNode::shutdown(int level)
841 DEBTRACE("PythonNode::shutdown " << level);
842 if(_mode=="local")return;
846 _container->shutdown(level);
850 void PythonNode::imposeResource(const std::string& resource_name,
851 const std::string& container_name)
853 if(!resource_name.empty() && !container_name.empty())
855 _imposedResource = resource_name;
856 _imposedContainer = container_name;
860 bool PythonNode::canAcceptImposedResource()
862 return _container != nullptr && _container->canAcceptImposedResource();
865 bool PythonNode::hasImposedResource()const
867 return PythonEntry::hasImposedResource();
870 std::string PythonNode::pythonEntryName()const
872 if(isUsingPythonCache())
873 return "DEFAULT_NAME_FOR_UNIQUE_PYTHON_NODE_ENTRY";
878 bool PythonNode::isUsingPythonCache()const
882 found = _container->isUsingPythonCache();
886 void PythonNode::freeKernelPynode()
888 if(!CORBA::is_nil(_pynode))
892 _pynode->UnRegister();
896 DEBTRACE("Trouble when pynode->UnRegister!")
898 _pynode = Engines::PyScriptNode::_nil();
902 Node *PythonNode::simpleClone(ComposedNode *father, bool editionOnly) const
904 return new PythonNode(*this,father);
907 void PythonNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
910 _pynode=objContainer->createPyScriptNode(pythonEntryName().c_str(),getScript().c_str());
914 Engines::PyNodeBase_var PythonNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
916 Engines::PyScriptNode_var ret(objContainer->getDefaultPyScriptNode(pythonEntryName().c_str()));
917 if(!CORBA::is_nil(ret))
921 return Engines::PyNodeBase::_narrow(ret);
924 void PythonNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
926 if(CORBA::is_nil(_pynode))
927 _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
930 Engines::PyScriptNode_var tmpp(Engines::PyScriptNode::_narrow(remoteInterp));
931 if(!_pynode->_is_equivalent(tmpp))
934 _pynode=Engines::PyScriptNode::_narrow(remoteInterp);
937 _pynode->assignNewCompiledCode(getScript().c_str());
940 Engines::PyNodeBase_var PythonNode::getRemoteInterpreterHandle()
942 return Engines::PyNodeBase::_narrow(_pynode);
945 //! Create a new node of same type with a given name
946 PythonNode* PythonNode::cloneNode(const std::string& name)
948 PythonNode* n=new PythonNode(name);
949 n->setScript(_script);
950 list<InputPort *>::iterator iter;
951 for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
953 InputPyPort *p=(InputPyPort *)*iter;
954 DEBTRACE( "port name: " << p->getName() );
955 DEBTRACE( "port kind: " << p->edGetType()->kind() );
956 n->edAddInputPort(p->getName(),p->edGetType());
958 list<OutputPort *>::iterator iter2;
959 for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
961 OutputPyPort *p=(OutputPyPort *)*iter2;
962 DEBTRACE( "port name: " << p->getName() );
963 DEBTRACE( "port kind: " << p->edGetType()->kind() );
964 n->edAddOutputPort(p->getName(),p->edGetType());
969 void PythonNode::applyDPLScope(ComposedNode *gfn)
971 std::vector< std::pair<std::string,int> > ret(getDPLScopeInfo(gfn));
978 std::size_t sz(ret.size());
980 for(std::size_t i=0;i<sz;i++)
982 const std::pair<std::string,int>& p(ret[i]);
983 PyObject *elt(PyTuple_New(2));
984 PyTuple_SetItem(elt,0,PyUnicode_FromString(p.first.c_str()));
985 PyTuple_SetItem(elt,1,PyLong_FromLong(p.second));
986 PyList_SetItem(ob,i,elt);
989 if(_mode==REMOTE_NAME)
991 Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);
994 PyObject *serializationInput(PyObject_CallFunctionObjArgs(_pyfuncSimpleSer,ob,NULL));
996 char *serializationInputC(0);
998 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
999 throw Exception("DistributedPythonNode problem in python pickle");
1000 serializationInputCorba->length(len);
1001 for(int i=0; i < len ; i++)
1002 serializationInputCorba[i]=serializationInputC[i];
1003 Py_XDECREF(serializationInput);
1005 _pynode->defineNewCustomVar(DPL_INFO_NAME,serializationInputCorba);
1010 PyDict_SetItemString(_context,DPL_INFO_NAME,ob);
1015 PyFuncNode::PyFuncNode(const PyFuncNode& other, ComposedNode *father):InlineFuncNode(other,father),_pyfunc(0)
1017 _implementation = PythonNode::IMPL_NAME;
1020 _context=PyDict_New();
1021 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1022 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
1025 msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
1026 _errorDetails=msg.str();
1027 throw Exception(msg.str());
1032 PyFuncNode::PyFuncNode(const std::string& name): InlineFuncNode(name),_pyfunc(0)
1035 _implementation = PythonNode::IMPL_NAME;
1036 DEBTRACE( "PyFuncNode::PyFuncNode " << name );
1039 _context=PyDict_New();
1040 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1041 if( PyDict_SetItemString( _context, "__builtins__", getSALOMERuntime()->getBuiltins() ))
1044 msg << "Not possible to set builtins" << __FILE__ << ":" << __LINE__;
1045 _errorDetails=msg.str();
1046 throw Exception(msg.str());
1051 PyFuncNode::~PyFuncNode()
1053 if(!CORBA::is_nil(_pynode))
1055 _pynode->UnRegister();
1059 void PyFuncNode::init(bool start)
1061 initCommonPartWithoutStateManagement(start);
1062 if(_state == YACS::DISABLED)
1064 exDisabledState(); // to refresh propagation of DISABLED state
1067 if(start) //complete initialization
1068 setState(YACS::READY);
1069 else if(_state > YACS::LOADED)// WARNING FuncNode has internal vars (CEA usecase) ! Partial initialization (inside a loop). Exclusivity of funcNode.
1070 setState(YACS::TORECONNECT);
1073 void PyFuncNode::checkBasicConsistency() const
1075 DEBTRACE("checkBasicConsistency");
1076 InlineFuncNode::checkBasicConsistency();
1080 res=Py_CompileString(_script.c_str(),getName().c_str(),Py_file_input);
1083 std::string error="";
1084 PyObject* new_stderr = newPyStdOut(error);
1085 PySys_SetObject((char*)"stderr", new_stderr);
1087 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1088 Py_DECREF(new_stderr);
1089 throw Exception(error);
1096 void PyFuncNode::load()
1098 DEBTRACE( "---------------PyfuncNode::load function---------------" );
1099 if(_mode==PythonNode::REMOTE_NAME)
1105 void PyFuncNode::loadRemote()
1107 commonRemoteLoad(this);
1110 void PyFuncNode::loadLocal()
1112 DEBTRACE( "---------------PyFuncNode::load function " << getName() << " ---------------" );
1113 DEBTRACE( _script );
1116 list<OutputPort *>::iterator iter;
1117 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1119 OutputPyPort *p=(OutputPyPort *)*iter;
1120 DEBTRACE( "port name: " << p->getName() );
1121 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1127 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1129 std::ostringstream stream;
1130 stream << "/tmp/PythonNode_";
1133 PyObject* code=Py_CompileString(_script.c_str(), stream.str().c_str(), Py_file_input);
1137 PyObject* new_stderr = newPyStdOut(_errorDetails);
1138 PySys_SetObject((char*)"stderr", new_stderr);
1140 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1141 Py_DECREF(new_stderr);
1142 throw Exception("Error during execution");
1144 PyObject *res = PyEval_EvalCode( code, _context, _context);
1148 DEBTRACE( "_context refcnt: " << _context->ob_refcnt );
1149 if(PyErr_Occurred ())
1152 PyObject* new_stderr = newPyStdOut(_errorDetails);
1153 PySys_SetObject((char*)"stderr", new_stderr);
1154 ofstream errorfile(stream.str().c_str());
1155 if (errorfile.is_open())
1157 errorfile << _script;
1161 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1162 Py_DECREF(new_stderr);
1163 throw Exception("Error during execution");
1166 _pyfunc=PyDict_GetItemString(_context,_fname.c_str());
1167 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1171 PyObject* new_stderr = newPyStdOut(_errorDetails);
1172 PySys_SetObject((char*)"stderr", new_stderr);
1174 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1175 Py_DECREF(new_stderr);
1176 throw Exception("Error during execution");
1178 DEBTRACE( "---------------End PyFuncNode::load function---------------" );
1182 void PyFuncNode::execute()
1184 if(_mode==PythonNode::REMOTE_NAME)
1190 void PyFuncNode::executeRemote()
1192 DEBTRACE( "++++++++++++++ PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1194 throw Exception("DistributedPythonNode badly loaded");
1196 if(dynamic_cast<HomogeneousPoolContainer *>(getContainer()))
1199 loadPythonAdapter(this,dummy);
1200 _pynode->executeAnotherPieceOfCode(getScript().c_str());
1203 Engines::pickledArgs_var serializationInputCorba(new Engines::pickledArgs);;
1205 #if PY_VERSION_HEX < 0x03070000
1206 std::unique_lock<std::mutex> lock(data_mutex);
1210 //===========================================================================
1211 // Get inputs in input ports, build a Python tuple and pickle it
1212 //===========================================================================
1213 PyObject *args(PyTuple_New(getNumberOfInputPorts()));
1215 for(std::list<InputPort *>::iterator iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++,pos++)
1217 InputPyPort *p=(InputPyPort *)*iter2;
1220 PyTuple_SetItem(args,pos,ob);
1223 PyObject_Print(args,stderr,Py_PRINT_RAW);
1226 PyObject *serializationInput=PyObject_CallObject(_pyfuncSer,args);
1228 //The pickled string may contain NULL characters so use PyString_AsStringAndSize
1229 char *serializationInputC(0);
1231 if (PyBytes_AsStringAndSize(serializationInput, &serializationInputC, &len))
1232 throw Exception("DistributedPythonNode problem in python pickle");
1234 serializationInputCorba->length(len);
1235 for(int i=0; i < len ; i++)
1236 serializationInputCorba[i]=serializationInputC[i];
1237 Py_DECREF(serializationInput);
1240 //===========================================================================
1241 // Execute in remote Python node
1242 //===========================================================================
1243 DEBTRACE( "-----------------starting remote python invocation-----------------" );
1244 Engines::pickledArgs_var resultCorba;
1247 resultCorba=_pynode->execute(getFname().c_str(),serializationInputCorba);
1249 catch( const SALOME::SALOME_Exception& ex )
1251 std::string msg="Exception on remote python invocation";
1253 msg += ex.details.text.in();
1255 throw Exception(msg);
1257 catch(CORBA::COMM_FAILURE& ex)
1259 std::ostringstream msg;
1260 msg << "Exception on remote python invocation." << std::endl ;
1261 msg << "Caught system exception COMM_FAILURE -- unable to contact the "
1262 << "object." << std::endl;
1263 _errorDetails=msg.str();
1264 throw Exception(msg.str());
1266 catch(CORBA::SystemException& ex)
1268 std::ostringstream msg;
1269 msg << "Exception on remote python invocation." << std::endl ;
1270 msg << "Caught a CORBA::SystemException." ;
1273 CORBA::TypeCode_var tc = tmp.type();
1274 const char *p = tc->name();
1280 _errorDetails=msg.str();
1281 throw Exception(msg.str());
1283 catch(CORBA::Exception& ex)
1285 std::ostringstream msg;
1286 msg << "Exception on remote python invocation." << std::endl ;
1287 msg << "Caught CORBA::Exception. " ;
1290 CORBA::TypeCode_var tc = tmp.type();
1291 const char *p = tc->name();
1297 _errorDetails=msg.str();
1298 throw Exception(msg.str());
1300 catch(omniORB::fatalException& fe)
1302 std::ostringstream msg;
1303 msg << "Exception on remote python invocation." << std::endl ;
1304 msg << "Caught omniORB::fatalException:" << std::endl;
1305 msg << " file: " << fe.file() << std::endl;
1306 msg << " line: " << fe.line() << std::endl;
1307 msg << " mesg: " << fe.errmsg() << std::endl;
1308 _errorDetails=msg.str();
1309 throw Exception(msg.str());
1311 DEBTRACE( "-----------------end of remote python invocation-----------------" );
1312 //===========================================================================
1313 // Get results, unpickle and put them in output ports
1314 //===========================================================================
1315 char *resultCorbaC=new char[resultCorba->length()+1];
1316 resultCorbaC[resultCorba->length()]='\0';
1317 for(int i=0;i<resultCorba->length();i++)
1318 resultCorbaC[i]=resultCorba[i];
1321 #if PY_VERSION_HEX < 0x03070000
1322 std::unique_lock<std::mutex> lock(data_mutex);
1326 PyObject *resultPython(PyBytes_FromStringAndSize(resultCorbaC,resultCorba->length()));
1327 delete [] resultCorbaC;
1328 PyObject *args(PyTuple_New(1)),*ob(0);
1329 PyTuple_SetItem(args,0,resultPython);
1330 PyObject *finalResult=PyObject_CallObject(_pyfuncUnser,args);
1333 DEBTRACE( "-----------------PythonNode::outputs-----------------" );
1335 if(finalResult == Py_None)
1337 else if(PyTuple_Check(finalResult))
1338 nres=PyTuple_Size(finalResult);
1340 if(getNumberOfOutputPorts() != nres)
1342 std::string msg="Number of output arguments : Mismatch between definition and execution";
1343 Py_DECREF(finalResult);
1345 throw Exception(msg);
1351 for(std::list<OutputPort *>::iterator iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++, pos++)
1353 OutputPyPort *p=(OutputPyPort *)*iter;
1354 DEBTRACE( "port name: " << p->getName() );
1355 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1356 DEBTRACE( "port pos : " << pos );
1357 if(PyTuple_Check(finalResult))
1358 ob=PyTuple_GetItem(finalResult,pos) ;
1361 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1364 Py_DECREF(finalResult);
1366 catch(ConversionException& ex)
1368 Py_DECREF(finalResult);
1369 _errorDetails=ex.what();
1374 DEBTRACE( "++++++++++++++ ENDOF PyFuncNode::executeRemote: " << getName() << " ++++++++++++++++++++" );
1377 void PyFuncNode::executeLocal()
1379 DEBTRACE( "++++++++++++++ PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1383 if(!_pyfunc)throw Exception("PyFuncNode badly loaded");
1386 DEBTRACE( "---------------PyFuncNode::inputs---------------" );
1387 PyObject* args = PyTuple_New(getNumberOfInputPorts()) ;
1388 list<InputPort *>::iterator iter2;
1389 for(iter2 = _setOfInputPort.begin(); iter2 != _setOfInputPort.end(); iter2++)
1391 InputPyPort *p=(InputPyPort *)*iter2;
1392 DEBTRACE( "port name: " << p->getName() );
1393 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1396 PyObject_Print(ob,stderr,Py_PRINT_RAW);
1399 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1401 PyTuple_SetItem(args,pos,ob);
1402 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1405 DEBTRACE( "---------------End PyFuncNode::inputs---------------" );
1407 DEBTRACE( "----------------PyFuncNode::calculation---------------" );
1409 PyObject_Print(_pyfunc,stderr,Py_PRINT_RAW);
1411 PyObject_Print(args,stderr,Py_PRINT_RAW);
1414 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1415 PyObject* result = PyObject_CallObject( _pyfunc , args ) ;
1416 DEBTRACE( "_pyfunc refcnt: " << _pyfunc->ob_refcnt );
1423 PyObject* new_stderr = newPyStdOut(_errorDetails);
1424 PySys_SetObject((char*)"stderr", new_stderr);
1425 std::ostringstream stream;
1426 stream << "/tmp/PythonNode_";
1428 ofstream errorfile(stream.str().c_str());
1429 if (errorfile.is_open())
1431 errorfile << _script;
1435 PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"__stderr__"));
1436 Py_DECREF(new_stderr);
1437 throw Exception("Error during execution");
1439 DEBTRACE( "----------------End PyFuncNode::calculation---------------" );
1441 DEBTRACE( "-----------------PyFuncNode::outputs-----------------" );
1443 if(result == Py_None)
1445 else if(PyTuple_Check(result))
1446 nres=PyTuple_Size(result);
1448 if(getNumberOfOutputPorts() != nres)
1450 std::string msg="Number of output arguments : Mismatch between definition and execution";
1453 throw Exception(msg);
1458 PyObject_Print(result,stderr,Py_PRINT_RAW);
1461 list<OutputPort *>::iterator iter;
1464 for(iter = _setOfOutputPort.begin(); iter != _setOfOutputPort.end(); iter++)
1466 OutputPyPort *p=(OutputPyPort *)*iter;
1467 DEBTRACE( "port name: " << p->getName() );
1468 DEBTRACE( "port kind: " << p->edGetType()->kind() );
1469 DEBTRACE( "port pos : " << pos );
1470 if(PyTuple_Check(result))ob=PyTuple_GetItem(result,pos) ;
1472 DEBTRACE( "ob refcnt: " << ob->ob_refcnt );
1474 PyObject_Print(ob,stderr,Py_PRINT_RAW);
1481 catch(ConversionException& ex)
1484 _errorDetails=ex.what();
1487 DEBTRACE( "-----------------End PyFuncNode::outputs-----------------" );
1490 DEBTRACE( "++++++++++++++ End PyFuncNode::execute: " << getName() << " ++++++++++++++++++++" );
1493 Node *PyFuncNode::simpleClone(ComposedNode *father, bool editionOnly) const
1495 return new PyFuncNode(*this,father);
1498 void PyFuncNode::createRemoteAdaptedPyInterpretor(Engines::Container_ptr objContainer)
1500 if(!CORBA::is_nil(_pynode))
1501 _pynode->UnRegister();
1502 _pynode=objContainer->createPyNode(getName().c_str(),getScript().c_str());
1505 Engines::PyNodeBase_var PyFuncNode::retrieveDftRemotePyInterpretorIfAny(Engines::Container_ptr objContainer) const
1507 Engines::PyNode_var ret(objContainer->getDefaultPyNode(getName().c_str()));
1508 if(!CORBA::is_nil(ret))
1512 return Engines::PyNodeBase::_narrow(ret);
1515 void PyFuncNode::assignRemotePyInterpretor(Engines::PyNodeBase_var remoteInterp)
1517 if(!CORBA::is_nil(_pynode))
1519 Engines::PyNode_var tmpp(Engines::PyNode::_narrow(remoteInterp));
1520 if(_pynode->_is_equivalent(tmpp))
1523 if(!CORBA::is_nil(_pynode))
1524 _pynode->UnRegister();
1525 _pynode=Engines::PyNode::_narrow(remoteInterp);
1528 Engines::PyNodeBase_var PyFuncNode::getRemoteInterpreterHandle()
1530 return Engines::PyNodeBase::_narrow(_pynode);
1533 //! Create a new node of same type with a given name
1534 PyFuncNode* PyFuncNode::cloneNode(const std::string& name)
1536 PyFuncNode* n=new PyFuncNode(name);
1537 n->setScript(_script);
1538 n->setFname(_fname);
1539 list<InputPort *>::iterator iter;
1540 for(iter = _setOfInputPort.begin(); iter != _setOfInputPort.end(); iter++)
1542 InputPyPort *p=(InputPyPort *)*iter;
1543 n->edAddInputPort(p->getName(),p->edGetType());
1545 list<OutputPort *>::iterator iter2;
1546 for(iter2 = _setOfOutputPort.begin(); iter2 != _setOfOutputPort.end(); iter2++)
1548 OutputPyPort *p=(OutputPyPort *)*iter2;
1549 n->edAddOutputPort(p->getName(),p->edGetType());
1554 std::string PyFuncNode::getContainerLog()
1556 return PythonEntry::GetContainerLog(_mode,_container,this);
1559 void PyFuncNode::shutdown(int level)
1561 DEBTRACE("PyFuncNode::shutdown " << level);
1562 if(_mode=="local")return;
1565 if(!CORBA::is_nil(_pynode)) _pynode->UnRegister();
1566 _pynode=Engines::PyNode::_nil();
1567 _container->shutdown(level);
1571 void PyFuncNode::imposeResource(const std::string& resource_name,
1572 const std::string& container_name)
1574 if(!resource_name.empty() && !container_name.empty())
1576 _imposedResource = resource_name;
1577 _imposedContainer = container_name;
1581 bool PyFuncNode::canAcceptImposedResource()
1583 return _container != nullptr && _container->canAcceptImposedResource();
1586 bool PyFuncNode::hasImposedResource()const
1588 return PythonEntry::hasImposedResource();